This is the project code at the start of Devember 2016.

This is the code before any Devember work has actually started, and as a result
this is just the boilerplate ts-game-engine code, stripped down as much as
possible.

This is the project code as of the end of the first day of Devember.

This begins the basics of the game area. We are currently capable of displaying
an arbitrary grid, although in practice what we really have is just a U shaped
cup that contains a bunch of empty cells with walls around the outside.

This is the project code as of the end of the sixth day of Devember.

A couple of small additions to the debug code from yesterday for clearing the
maze and making some existing click options debug only.

More importantly, we now support visual ball dropping in the maze, which looks a
lot nicer, and you can actually track what is happening, which is nice.

This is still crude but will be made pretty RSN (Real Soon Now)

This is the project code as of the end of the eleventh day of Devember.

Despite the many changes to the code base, no new functionalty has actually been
added.

Instead there has been some internal restructuring to allow for future changes
which require the entities to be able to render themselves even if they are no
longer contained within the maze structure itself.

This is the project code as of the end of the twelth day of Devember.

This adds some extensions to the ActorList to allow us to get at live entities
as well as modifications to the Ball and Brick class to allow us to easily hide
and show them and determine when they are finished vanishing away.

With these in place we can now trigger a check every time a ball finished moving
(or finished vanishing if it gets to the bottom row) and then see if there are
any moves left.

When there are not, we vanish away all of the gray bricks. We currently have a
boolean flag set up to track when this happens so that we can trigger the next
phase, which would be dropping all of the existing balls.

This is the project code as of the end of the thirteenth day of Devember.

This includes a bit of debug code refactoring, other code cleanup, and the logic
needed to end a round. Specifically, when the last move is made, the gray bricks
vanish, then the balls still in the maze get one last chance to drop into a
scoring position.

This is the project code as of the end of the fourteenth day of Devember.

Today brings massive refactoring, shifting all of the debugging code and maze
generation code out into sub-classes. In order to get this to operate as
desired, the Maze entity gained some extra accessors.

This is the project code as of the end of the fifteenth day of Devember.

Changes today are a Player entity that is controllable by the player and which
can push balls into the maze.

There is not a lot of error checking, but we're starting to look more like a
game!

This is the project code as of the end of the sixteenth day of Devember.

On this day the robot uprising began, inasmuch as now the AI can select a move
and execute it.

This is still in the testing phase.

This is the project code as of the end of the seventeenth day of Devember.

Today we fix up the AI to be a little smarter (left out of yesterday's
development due to time) and do a little code cleanup on some entities.

This is the project code as of the end of the eighteenth day of Devember.

We have added in the state machine that has been much talked about in the
development log and started using it to control things.

Currently the only outwardly visible effect of this is console output that
mentions state changes and that the player cannot be moved during maze
generation or while a ball is dropping.

This is the project code as of the end of the nineteenth  day of Devember.

Today adds in the logic needed to swap between a human and computer player,
allowing each of them to take turns. To this end the Player entity is extended
to be able to make decisions as well as be hidden.

We respond to state changes to swap between players as needed.

This is not currently fully implemented, since there is still only one set of
balls that both players share. Additionally it does not check to see if a player
has a valid move before it is their turn, and after the final ball is dropped it
keeps swapping between players as the remaining balls are dropped out of the
maze.

This is the project code as of the end of the second day of Devember.

There is now support for the following (animated) entities: black holes, gray
blocks (vanishing and appearing), bonus tiles (vanishing and appearing), as well
as both kinds of arrow tiles with appropriate animation states to flip their
directions around.

This is everything needed in order to start level generation, with the exception
of the ball and player entities, which are not vital to that process.

This is the project code as of the end of the twentieth day of Devember.

A bit of progress has been made in that we now generate the balls for each
player into a separate data structure, one for each player, and then we can swap
one or the other in as we need in order to show the correct set of balls.

This is currently buggy for unknown reasons, so the computer will not take his
turn after you take your turn because he has no balls to play with (except that
he does and for some reason we just can't see them).

This is the project code as of the end of the twenty first day of Devember.

The only progrss made today was to include some extra debugging logic and then
fix the horrible (and predictably stupid) bug that I ran into yesterday.

As such the players swap turns and swap balls now.

This is the project code as of the end of the sixth day of Devember.

Our state machine can now be used as a timer while it's in a state, and we
properly handle checking to ensure that a player has a valid move before we
allow them to take a turn.

This required a bit of a reseign on the maze content ball API so that instead of
swapping between ball sets you can just display one or the other on command and
the set updates as balls are pushed.

This is the project code as of the end of the twenty fourth day of Devember.

The code to remove all gray bricks and to do the final ball drop has been put
under the control of the state machine, with the gray brick vanish happening
when we detect that neither player can make any further moves.

This is the project code as of the end of the twenty fourth day of Devember.

Here we have fixed the drop bug from yesterday, in which it was possible for
the final ball drop to stop because after a ball vanished another was not
selected. This was due to a bug in the reaping code for vanished balls.

Additionally we fixed a couple of other bugs; handling when there are no gray
bricks to remove and making sure we don't prematurely switch away to the next
dropping ball while one is still dropping.

This is the project code as of the end of the twenty fifth day of Devember.

This adds in the full ability to remove blocked balls and to have a callback for
when this happens.

This allows us to do our scoring for balls removed naturally, during the end of
the game final ball drop, as well as when blocked balls can go no farther.

This is the project code as of the end of the twenty sixth day of Devember.

This day adds some bug fixes from yesterday's code (small typo) as well as full
scoring. This more or less makes this a playable single round prototype of the
game.