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

This is the last of the Devember work on this particular prototype. Although
there is no sound and music, this is easy to add once selected using the
techniques from the devember-2015 codebase.

Instead, this adds in one last missing big of visual flair to make the game
easier to play; a billboard that tells you what is going on as the game
progresses.

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

This includes several game play fixes and improvements, such as a game over
screen, random player selection, the ability to toggle and view the computer
balls while taking your turn, and a visual indication that a ball is being
vanished out of the level.

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

This adds the ability to track rounds of play and a title screen that allows you
to set the kind of game to play.

This extends the Bolo Ball game types to also include a short game which is
played with half the number of balls.

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

Simple changes today; this fixes the last known bug having to do with teleport
entities. The entity now makes sure that it doesn't choose a blocked output
location (if it can't do that, it does nothing).

Additionally, if the ball moves off of a teleport that it was blocking, the
entrance is restored so that another ball can fall through it.

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

The maze generation has been tweaked to generate (arguably) better random mazes
by having it generate items per column instead of per row, so that we can always
ensure that there is no column with a straight path to the bottom of the maze.

Also, the bug where the player can push a blocked ball on their turn has been
fixed, as well as the issue with unplayable balls remaining on the screen after
the final phase begins.

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.

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 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 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 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 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 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 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 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 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 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 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 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 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 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.