Added actions to add a static ball to the page

src/commands/randomizeEncounter.ts

@@ -3,6 +3,20 @@ import OutsideContext from '../context/OutsideContext';
 
 export type RandomizeEncounterAction = Action<undefined, OutsideContext>;
 
-export default function randomizeEncounter({ state: outsideContext }: RandomizeEncounterAction) {
-	outsideContext.randomizeEncounter();
+export default function randomizeEncounter({ state: outside }: RandomizeEncounterAction) {
+	const monsters = outside.getMonsterDefinitions();
+	const num = Math.floor(Math.random() * monsters.length);
+	const monster = monsters[num];
+	const {
+		heights,
+		name
+	} = monster;
+	const distance = Math.random() * 8 + 2;
+	const height = Math.random() * (heights.max - heights.min) + heights.min;
+
+	outside.setMonster({
+		name,
+		height,
+		distance
+	});
 };

src/commands/removeDerpyball.ts

@@ -0,0 +1,8 @@
+import { Action } from '../framework/Executor';
+import OutsideContext from '../context/OutsideContext';
+
+export type RemoveDerpyballAction = Action<undefined, OutsideContext>;
+
+export default function removeDerpyball({ state: outside }: RemoveDerpyballAction) {
+	outside.removeBall();
+}

src/commands/throwDerpyball.ts

@@ -0,0 +1,10 @@
+import { Action } from '../framework/Executor';
+import OutsideContext, { Throw } from '../context/OutsideContext';
+
+export type ThrowDerpyballAction = Action<Throw, OutsideContext>;
+
+export default function throwDerpyball({ payload, state: outside }: ThrowDerpyballAction) {
+	if (payload) {
+		outside.throwBall(payload)
+	}
+}

src/containers/ControlsContainer.ts

@@ -0,0 +1,26 @@
+import Container from '../framework/Container';
+import { ActionType, State } from '../initialize';
+import Controls, { ControlsProperties } from '../widgets/Controls';
+import { Throw } from '../context/OutsideContext';
+
+const ControlsContainer = Container(Controls, [ State.App, State.Executor ], {
+	getProperties([ app, executor]): ControlsProperties {
+		return {
+			onActionButtonPressed() {
+				console.log('pressed', app.state);
+				const derpyball: Throw = {
+					direction: [ 1, 0, 0],
+					initialTime: performance.now(),
+					position: [ 0, 3, -4],
+					speed: 1
+				};
+				executor.execute({ type: ActionType.ThrowDerpyball, payload: derpyball });
+			},
+			onActionButtonReleased() {
+				console.log('released', app.state);
+			}
+		}
+	}
+});
+
+export default ControlsContainer;

src/containers/OutsideContainer.ts

@@ -2,14 +2,16 @@ import Outside, { OutsideProperties } from '../widgets/Outside';
 import Container from '../framework/Container';
 import { throws } from '../util/properties';
 import OutsideContext from '../context/OutsideContext';
-import { State } from '../initialize';
+import { ActionType, State } from '../initialize';
 import AssetContext from '../context/AssetContext';
+import Executor from '../framework/Executor';
 
-const OutsideContainer = Container(Outside, [ State.Outside, State.Asset ], {
-	getProperties(payload: [ OutsideContext, AssetContext ]): OutsideProperties {
+const OutsideContainer = Container(Outside, [ State.Outside, State.Asset, State.Executor ], {
+	getProperties(payload: [ OutsideContext, AssetContext, Executor ]): OutsideProperties {
 		const [
 			outside = throws(),
-			appContext = throws()
+			appContext = throws(),
+			executor = throws()
 		] = payload;
 		let monster: OutsideProperties['monster'];
 		const monsterInfo = outside.monster;
@@ -27,7 +29,12 @@ const OutsideContainer = Container(Outside, [ State.Outside, State.Asset ], {
 		}
 		return {
 			environment: outside.environment,
-			monster
+			derpyball: outside.derpyball,
+			monster,
+
+			removeDerpyball() {
+				executor.execute(ActionType.RemoveDerpyball);
+			}
 		}
 	}
 });

src/context/OutsideContext.ts

@@ -1,4 +1,5 @@
 import { InjectorBase } from '../framework/InjectorBase';
+import { assign } from '@dojo/core/lang';
 
 interface Monster {
 	distance: number;
@@ -12,6 +13,16 @@ export const enum Environment {
 	Forest = 'forest'
 }
 
+declare type Dimension3 = [ number, number, number ];
+
+export interface Throw {
+	direction: Dimension3;
+	initialTime: number;
+	position: Dimension3;
+	speed: number;
+	thrownTime?: number;
+}
+
 /**
  * Defines a monster's traits
  */
@@ -28,12 +39,14 @@ export interface MonsterDefinition {
 }
 
 export default class OutsideContext extends InjectorBase {
-	private _environment: Environment = Environment.Forest;
+	environment: Environment = Environment.Forest;
+
+	private _derpyball?: Throw;
 	private _monster?: Monster;
 	private _monsterDefinitions: Map<string, MonsterDefinition> = new Map();
 
-	get environment(): Environment {
-		return this._environment;
+	get derpyball(): Throw | undefined {
+		return this._derpyball;
 	}
 
 	get monster(): Monster | undefined {
@@ -44,39 +57,34 @@ export default class OutsideContext extends InjectorBase {
 		this._monsterDefinitions.set(definitions.name, definitions);
 	}
 
-	randomizeEncounter() {
-		const {
-			heights,
-			name,
-		} = this.randomMonster();
-		const distance = Math.random() * 8 + 2;
-		const height = Math.random() * (heights.max - heights.min) + heights.min;
+	ballThrown() {
+		if (this._derpyball && !this._derpyball.thrownTime) {
+			this._derpyball.thrownTime = performance.now();
+		}
+	}
 
-		this.setMonster({
-			name,
-			height,
-			distance
-		});
+	getMonsterDefinitions(): MonsterDefinition[] {
+		return Array.from(this._monsterDefinitions.values());
 	}
 
-	setEnvironment(name: Environment) {
-		if (this._environment !== name) {
-			this._environment = name;
-			this.emitInvalidate();
+	removeBall() {
+		if (this._derpyball) {
+			this._derpyball = undefined;
 		}
 	}
 
-	setMonster(monster: Monster | undefined) {
-		if (this._monster !== monster) {
-			this._monster = monster;
-			this.emitInvalidate();
+	throwBall(value: Throw) {
+		if (!this._derpyball && value) {
+			this._derpyball = {
+				direction: <Dimension3> Array.from(value.direction),
+				initialTime: value.initialTime || performance.now(),
+				position: <Dimension3> Array.from(value.position),
+				speed: value.speed
+			}
 		}
 	}
 
-	private randomMonster() {
-		const max = this._monsterDefinitions.size;
-		const num = Math.floor(Math.random() * max);
-		const definitions = Array.from(this._monsterDefinitions.values());
-		return definitions[num];
+	setMonster(monster: Monster | undefined) {
+		this._monster = assign({}, monster);
 	}
 }

src/framework/Executor.ts

@@ -9,7 +9,7 @@ export interface Command<T extends Action = Action> {
 
 export interface Action<T = any, U = any> {
 	type: string;
-	payload?: T;
+	payload: T;
 	state: U;
 }
 

src/initialize.ts

@@ -8,6 +8,8 @@ import randomizeEncounter from './commands/randomizeEncounter';
 import registerMonsters from './commands/registerMonsters';
 import AssetContext from './context/AssetContext';
 import loadedMonsters from './commands/loadedMonsters';
+import removeDerpyball from './commands/removeDerpyball';
+import throwDerpyball from './commands/throwDerpyball';
 
 // Require globals
 require('aframe');
@@ -23,20 +25,24 @@ export const enum State {
 
 export const enum ActionType {
 	Initialize = 'initialize',
-	LoadMonsters = 'loadMonsters',
 	LoadedMonsters = 'loadedMonsters',
+	LoadMonsters = 'loadMonsters',
 	RandomizeEncounter = 'randomizeEncounter',
-	RegisterMonsters = 'registerMonsters'
+	RegisterMonsters = 'registerMonsters',
+	RemoveDerpyball = 'removeDerpyball',
+	ThrowDerpyball = 'throwDerpyball'
 }
 
 export default function initialize() {
 	const registry = new Registry();
 	const executor = new Executor(registry, [
 		{ type: ActionType.Initialize, handler: initializeApp, state: [ State.App, State.Executor ] },
-		{ type: ActionType.LoadMonsters, handler: loadMonsters, state: State.Executor },
 		{ type: ActionType.LoadedMonsters, handler: loadedMonsters, state: [ State.App, State.Executor ] },
+		{ type: ActionType.LoadMonsters, handler: loadMonsters, state: State.Executor },
 		{ type: ActionType.RandomizeEncounter, handler: randomizeEncounter, state: State.Outside },
-		{ type: ActionType.RegisterMonsters, handler: registerMonsters, state: [ State.Asset, State.Outside ] }
+		{ type: ActionType.RegisterMonsters, handler: registerMonsters, state: [ State.Asset, State.Outside ] },
+		{ type: ActionType.RemoveDerpyball, handler: removeDerpyball, state: State.Outside },
+		{ type: ActionType.ThrowDerpyball, handler: throwDerpyball, state: State.Outside }
 	]);
 	const appContext = new AppContext();
 	const assetContext = new AssetContext();

src/main.ts

@@ -1,6 +1,7 @@
 import { ProjectorMixin } from '@dojo/widget-core/mixins/Projector';
-import initialize from './initialize';
+import initialize, { ActionType } from './initialize';
 import AppContainer from './containers/AppContainer';
+import Executor from './framework/Executor';
 
 const root = document.querySelector('go-derpy') || undefined;
 
@@ -14,5 +15,31 @@ const projector = new Projector();
 projector.setProperties({ registry });
 projector.append(root);
 
+// TODO move this into a listener
+document.addEventListener('keydown', (event: KeyboardEvent) => {
+	if (event.keyCode === 32) {
+		const executor = registry.getInjector<Executor>('executor');
+		if (!executor) {
+			console.warn('missing executor');
+			return;
+		}
+		const ball = {
+			direction: [ 1, 0, 0],
+			initialTime: performance.now(),
+			position: [ 0, 3, -4],
+			speed: 1
+		};
+		executor.execute(ActionType.ThrowDerpyball, ball);
+	}
+	else if (event.key === '-') {
+		const executor = registry.getInjector<Executor>('executor');
+		if (!executor) {
+			console.warn('missing executor');
+			return;
+		}
+		executor.execute(ActionType.RemoveDerpyball);
+	}
+});
+
 (<any> root.ownerDocument).registry = registry;
 (<any> root.ownerDocument).projector = projector;

src/widgets/Controls.ts

@@ -7,12 +7,6 @@ export interface ControlsProperties {
 	onActionButtonReleased?: EventHandler
 }
 
-function logEvent(name: string) {
-	return (event: Event) => {
-		console.log(name, event);
-	}
-}
-
 export default class Controls extends WidgetBase<ControlsProperties> {
 	protected render(): DNode[] {
 		return [