Add a hitbox attribute to Bee

Right now the hitbox is the size of the Bee’s width and height, which
will very likely be too large.  But it is a simple starting point.
Draw a red rectangle hitbox over the bee

Because of the default values of the bee this currently covers the
entire player, making them flying red rectangles.
Add a ‘dead’ flag to bees and trying removing them when hit

This patch tries to determine when a bullet his entered the hitbox of
a bee and flags it is dead.  Bees that are dead are then removed.
However the code does not work, as the detection never registers for
some reason.
Merge branch 'stacks-for-bullets' into improve-bullets

* stacks-for-bullets:
  Remove unneeded code in Pattern:execute() for getting the node
  Document Pattern:execute() and its return value
  Remove ACTION_NODE_HANDLERS to NODE_HANDLERS
  Rewrite Pattern:execute() to use a difference recursive approach
  Partially fix the problem with bullet patterns not rendering
  Rename Pattern:executeAction() to Pattern:execute()
  Remove Pattern.currentAction
  Patterns: Only load bullets and actions with labels
  Begin switching to a stack-based parser for BulletML patterns
  Fix a typo in a comment for Pattern.load()
  Support <shape>dot</shape> for bullets
  Fix a bug with parsing <speed> of bullets
  Make sure current bullet index is correct after removing a bullet
  Implement basic support for <direction type="aim"/>
  Remove an unnecessary space in all of the bullet pattern files
  Add a bullet pattern test-case for testing <param> support
  Add basic description of <bullet> tags in pattern documentation
  Make it possible to load a bullet pattern from the command line
Correct the comment for Pattern.nodeStack

It was still using the old name ‘currentNode’ and had a misleading
description of its purpose and usage.
Track when we have finished executing a pattern

We introduce a property called Pattern.finishedExecution that is a
boolean indicating whether or not we need any future calls to
Pattern:execute().  Code can use this to determine when to stop
calling that method.  Without any indicator like this we could execute
the pattern forever, as we currently do.
Fix a bug in the return value of Pattern:execute() when waiting

We return false indicating that there is nothing left to execute in
the pattern, but that is not true if we are just sitting through a
<wait> node.  So we should return true instead.
Update the pattern timer earlier

When we call Pattern:execute() we now update the timer and check for
<wait> status before anything, with the exception of first checking
whether we have finished execution completely.  By updating the timer
before getting to any node processing we can save ourselves processing
time during <wait> periods and ensure that the timing values are
updated properly.
Add a Makefile for creating documentation

Right now this will only create an HTML version of the text document
that describes how to create bullet patterns.  It relies on Pandoc to
be available, and does not check for its installation.
Bee: Change the ‘hitbox’ property to contain width and height

A fundamental problem with the original approach of using X and Y
coordinates was that these were initially based on the width and
height of the player.  However, that was then treated as a coordinate
on the game screen, placing the hitbox in a place that never actually
matched up with the player’s location.

By defining the hitbox by only its width and height we can clamp it to
the player as he flies around, just like we already do with his
position.  Then we can calculate whether or not anything has entered
the hitbox with similar code.

Because this patch gets rid of the ‘x’ and ‘y’ properties of the
hitbox it also deletes the work-in-progress code inside the main loop
that was testing for collision detection.  Because now that code
fails and stops the game from running.
Bee: Turn the clamp code into a method

The method Bee:update() has some logic for ensuring that the position
of the bee is clamped to the screen.  This patch moves the logic into
its own method.  This is in preparation of needing to add any
extra logic for adjusting the hitbox on movement without bloating the
update method.
Bee: Add an isHitBy() method and test for bullet collision

This patch adds a method to the Bee object that accepts a bullet and
determines if it has made contact with the bee.  That’s all.  The
logic in the main game loop is what decides to flag the player dead.
Bee: Ensure the hitbox is centered on the player

This fixes a bug in the debugging code for drawing the hitbox to
ensure that the hitbox is clamped to the center of the player.  In
order to test this we shrink the hitbox to half the bee’s size.
Move all debugging patterns into their own ‘test’ directory

This is just house-cleaning.  As we create more patterns for enemies
and bosses we will resort to sub-directories for organization.  So
with that in mind let’s go ahead and put all our debugging patterns in
their own specific place.
Makefile: Add a ‘clean’ rule to delete the potb.love file
Makefile: Include art resources in potb.love when building

Now that the ‘master’ branch includes the bee code, continuing work on
the bullet patterns requires the inclusion of the bee art assets in
the Love file.  So we add that to the Makefile.
Patterns: Change test-4.xml to test a top-level <fire/> node

After the changes to how Pattern:execute() works we can now have
<fire/> nodes outside of an <action/> node.  We change this pattern
file to test support for that.  As of this patch, this pattern does
function correctly.
Patterns: Document the purpose of every test pattern

This adds comments to the top of every BulletML pattern that describes
the expected result of the pattern and what the test is focused on.
Patterns: Add a test case for placing <bullet/> nodes first
Patterns: Move code for testing <wait> into its own method

This patch takes the logic concerning <wait> out of Pattern:execute()
and moves it into its own method.  This helps readability by reducing
clutter of Pattern:execute().  And it also will isolate that part of
the code to help me fix a related bug: patterns are not continuing
execution after the appropriate <wait> time.