Initial commit

- Add empty HTML page.
- Add test web server.
- Add initial README.
Two heroes, no forces

-   Map is exactly the same size as the view.
-   Add walls around the view.
-   Add two heroes, red and blue, to the world, and display them with
    red and blue squares, respectively.
-   The heroes do not move yet, i.e. no forces applied.
Two heroes, repelling force

-   Add a repelling force between heroes.
Three teams with flags and fighters

- Three teams: red, green, blue.
- Add fighters with per-fighter fighter mode.
- Add 50 fighters per team.
- Add flags: avoid, moveTo to control heroes.
- Increase view size to 800x600.
- Increase FPS to 30.
- Use linear damping 6, and friction 1 by default for all bodies.
Hero levels, HP and damage

-   Add levels for heroes
-   Add symbols for heroes
-   Add HP/maxHP for all units
-   Damage units on contact with other teams
-   Remove dead units
-   Color intensity indicates health
Aggressive heroes, plan for force generalization

-   hero--hero force now attracts.
-   Add *MASSIVE* TODO note for generalizing forces and interactions
    between units.
-   Some more small TODOs added.
Static control panel, no icons

-   Add static control panel.
-   Disable physics engine.

NOTE:

-   No icons yet!
Game window with active controls

-   Move main `window.Gry` object into `src/Gry.js`.
-   Move `Hero` object into `src/Hero.js`.
-   Move DOM element creation from `index.html` to `src/Frag.js`.
-   Include black-and-white icons from `game-icons.net` under `img/`.
Units and Fighters

-   Introduce `Unit` objects, which encapsulate common parts of heroes
    and fighters.
-   Move `Fighter` object into `src/Fighter.js`.
-   Adapt `Hero` and `Fighter` objects to use `Unit`.
Code clean-up

-   Adapt physics engine to naming scheme: `Gry.System` from
    `src/phx.js` is now `Gry.Phx` from `src.Phx.js`.
-   Update `index.html` according to the new set files.
-   Ignore vim `.swp` files.
Class hierarchy, force clean-up

-   Add John Resig's Simple JavaScript Inheritence code as
    `src/Class.js`.
    -   See http://ejohn.org/blog/simple-javascript-inheritance/
-   Rename "flags" to "orbs"

-   Adapt existing objects to `Class`.
-   Introduce new class `Entity` as the base class for all game
    entities.
-   Introduce entity categories for collision filtering.
-   Split fighter modes to own/enemy functions.
-   Introduce new class `Orb`.
-   Clean up general box body/fixture def in `Phx`, and move specialized
    box body/fixture defs in their respective classes.
-   Introduce new class `Wall`.
-   Introduce force objects of the form `{sym,size}`, returned by the
    diggerent force functions.
-   Move forces into their respective entity files.
-   Rename "action pack" to "force pack" and extend it with additional
    fields.
Fix fighter--fighter force

-   Only the force pack was calculated, but it was never used to compute
    and apply the force.
Extract EntityType, EntityCategory, UnitType

-   Extract the list of available entity types from `Gry.Entity.Type`
    into `Gry.EntityType`. All entity subclasses use these constants.
-   Extract the list of available entity categories from
    `Gry.Entity.Category` into `Gry.EntityCategory`. All entity
    subclasses use these constants.
-   Extract the list of available unit types from `Gry.Unit.Type` into
    `Gry.UnitType`. The `Hero` and `Fighter` classes register themselves
    on this list.
Refactor force selection and application

-   The _force packs_ now include:
    -   `.eA`, `.eB`: entities
    -   `.tA`, `.tB`: the entity or unit type used with force selection
-   Force functions now take only the _force pack_ as their single
    parameter.
-   Force selection between two entities is now in `activeForces()`
    (in `src/Phx.js`).
-   Apllying force between two entities is now in `applyForcesFrom()`
    (in `src/Phx.js`).
Type-based force selector matrix

-   Collapse mode-based force functions for `Fighter` into one function
    per entity type (checking teams inside force function).
-   Create force selector matrix to pick forces to be applied based on
    entity types.
-   Turn hero--hero force into asymmetric.
Jumpy orbs

The `avoid` and `moveTo` orbs change place in regular intervals.

-   No orbs attached to `Hero` entities on creation.
-   Change `Orb.name` to `Orb.type`.
-   Introduce new field `Orb.id`.
-   Store the active `Orb` objects for each hero in an array instead
    of an object. The `Orb.type` holds the same information as the key
    in the object.
-   Add two methods to `Hero` objects for adding/removing `Orb` objects:
    `Hero.AddOrb()` and `Hero.RemoveOrbId()`.
-   Tweak `Orb` forces.
-   Move _linear damping_ onto default body definition as a property.
-   Add _angular damping_ property to default body definition.
Remove jQuery dependency from entity files

-   Remove the passed-in `jQuery` / `$` parameter from all entity files.
Parameterized orbs

-   Move the `avoid` and `moveTo` orb types into their own classes:
    `AvoidOrb` and `MoveToOrb`, which inherit from `Orb`.
-   Add `radius` and `range` parameters to `AvoidOrb` and `MoveToOrb`.
-   Draw the range of the orbs.
-   `Hero.AddOrb()` now expects a full `Orb` object.
Entities as user data, cleaner collision detection

-   The `Entity` base constructor saves the reference to itself as the
    user data on the Box2D body.
-   Collision detection is cleaner.
Collision filtering bits for entities

-   Move default unit body creation helpers to `src/Unit.js`.
-   `Hero` object override the default unit category bits.
-   Randomly sized jumpy orbs.