Currently when events are thrown the are emitted as "global", which means that multiple collision events may be thrown and every actor must check whether the event applies to them. This is incredibly inefficient, the EventDispatcher should only send events to actors that apply to them.

Probably should have a testing framework backing api claims :)

Actor

Enter view port event - 'enterviewport'
Exit view port event - 'exitviewport'
More specific collision events - 'collidesbottom', 'collidestop', 'collidesleft', collidesright'

Engine

load
gamestart
Key Combinations - 'ctrl+b'
mousemove
touchstart
touchend
touchmove
touchcancel

An unknown error is being thrown at the start of the game.

It looks to be an 'undefined' eventName being passed to the event dispatcher publish

[DEBUG] : Game started Engine.js:970
Uncaught TypeError: Cannot call method 'toLowerCase' of undefined Engine.js:1159
[DEBUG] : Game stopped Engine.js:970

This is useful when determining child actor positions globally in the game, and not relative to their parent.

Need to walk up the scene graph to find out what these are.

This is useful when you want to use retro fonts from sprite sheets

A logging setup around the concept of appenders would be useful and extensible as in log4j or log4net.

Doesn't make sense in the public API

The engine only implements naive collision detection on rectangles without rotation. It should provide a more robust system allowing arbitrary polygons to collide.

This is a huge problem when subclassing Actors

The engine needs new collision primitives that can collide with one another like:

BoundingCircle
BoundingBox
BoundingPoly
BoundingPixels

The current implementation assumes that sprite sheets will be nicely organized horizontally. Sprite sheets need the ability to arbitrarily slice source images to produce animations.

The loader should also display a progress bar indicating progress.

The progress bar drawing should be overloadable as well.

Something like

var loader = new Loader();
loader.addSound(somesound);
loader.addImage(someimage);
loader.addSpriteSheet(somess);
game.loader = loader;

or

game.start(loader);

or on game init

var game = new Game(600,400,'#game', loader);

StorageManager

Probably better as an Excalibur plug-in/feature.

• Abstract storage (amplify.store?)
• Stores "schema" version and handles migrations (up/down)
• get/set methods
• TypeScript generic support

Pseudocode

interface IPersistenceStore {
  version: string;
  migrations: IMigration[];

  init(): void;
  get<T>(key: string): T;
  store(key: string, value: any): void;
  // ... promises?
}

var storage: ex.Storage.IPersistenceStore = new ex.Storage.AmplifyStore("my-game-store");

// handle versioning?
storage.version = "2.0";
storage.migrations.add("1.0", "2.0", 
  (from, to) => { // from
  },
  (to, from) => { // to
  }); // ex.Storage.IVersionMigration

// set options
...

// load up existing DB/create new one and run migrations
storage.init();

// get prefs
var prefs = storage.get<IPreferences>("preferences");

// update prefs
prefs.showTutorials = false;

// store prefs
storage.store("preferences", prefs);

Hopefully we can just wrap storage providers rather than build our own. Really we just want to handle versioning.

Right now key press debug output is always drawn to the screen. Add a flag to the game container.

Maybe add an api for developers to attach a key press to toggle debug output.

Something like this perhaps

var color = Color.fromRGB(0,0,0);
var color2 = Color.fromHex('#ffffff');

or this

var color = new Color(0,0,0);
var color2 = new Color('#ffffff');

The idea of a sound sprite that push all your sound effects into a single sound file, so only one trip to the server is made. Similar to the idea behind atlases or sprite sheets.

Need a way to encode offsets and lengths to play the appropriate sound in the sound sprite.

We should utilize the HTML5 Sound Api and fall back as appropriate

Play Once
Cycle
Ping Pong

It might be a good idea to implement a finite state machine to assist in the scripting api.

Things like sound, actor, and physics have no business in the core

Efficient particle effects would be a really neat feature to have in a game.

I suspect we will need to play some tricks with an off screen canvas, after running some tests, the canvas shadowBlur is too slow.

Create a shim layer to handle drawing of each frame see mozilla mdn:
https://developer.mozilla.org/en-US/docs/Web/API/window.requestAnimationFrame

var requestAnimationFrame = window.requestAnimationFrame || window.mozRequestAnimationFrame ||
window.webkitRequestAnimationFrame || window.msRequestAnimationFrame;
window.requestAnimationFrame = requestAnimationFrame;

Engine needs to be part of the animation constructor for this to work.

var animation = new Animation(images, engine, ....);
animation.play(x,y);

Create some jsDoc style documentation about the engine

This would be relevant for npcs or enemies in the game where you would want to move them based on some 'script'

If we abstract the drawing layer, we could swap 2D canvas drawing for DOM, or WebGL. No rush on this feature.

Check out example here
http://www.html5rocks.com/en/tutorials/doodles/gamepad/

This would make it easier to do parallax type animations, as well as UI and foreground elements.

In some places times are expected in seconds like the ".delay" and the ".getAnimationByIndices" they should be converted to using milliseconds.

This will improve the performance of grid based collision detection.

//x, y, cellWidth, cellHeight, rowCount, colCount
var collisionMap = new CollisionMap(....);

var somethingUseful = collisiomMap.collides(actor);