grafx - Extensible Java Graphics Package Code

Defining scripts/.functions.sh. Moving some scripts to scripts/vid/ and others
to scripts/img/. Adding GIMP infrastructure. Simplifying existing scripts by
making use of .functions.sh. Renaming some scripts to dot files, e.g.
.generate-audio-track.sh.

Renaming LevelFinishedCausesNullNextBlock to FinNextBlockInterceptor because
this logic now also handles gameOver() states. It was needed to abstain from
calling the underlying nextBlockChanged() after gameOver(), because the game
logic will be calling BlockSource.getNextBlock() any number of times after
gameOver(), and when NextBlockSource is used, it also triggers a call to
nextBlockChanged(). We don't want that.

In SimpleGameLogic, on GAME_OVER also recording one next block after all other
events. This is causing problems right now, but I know how to fix and am
working on it. The problem is that the act of asking for the next block, for
purposes of recording to stream, is causing the next block display to be
changed automatically. Solution is to augment LevelFinishedCausesNullNextBlock
a little bit, perhaps even changing its name.

In SimpleGameLogic, taking a first stab at recording post-game events of type
NextBlockAfterFinEvent. Right now, recording one such event on level finished,
and not recording any on game over. Will test shortly.

Adding some TODO items to TODO.txt, before I forget about them.

In LocalBlockoutBoard, now handling BlockoutBoardEvent.NEXT_BLOCK_AFTER_FIN;
simply ignoring that event type, instead of puking on an unidentified event
type.

Adding use of LevelFinishedCausesNullNextBlock to LevelPlayback. In addition,
instead of using multiple (in this case it would have been already three)
instances of BoardstateToGamestateConverter, stitching together instead three
instances of BlockoutGamestateListener, using GamestateListenerChain.

Making better use of LevelFinishedCausesNullNextBlock, after that class started
to implement the additional interface NextBlockListener.

In SynchronizedModeGameRecorder, treating NEXT_BLOCK_AFTER_FIN in a special way
where the timestamp is always set to zero time delta from previous event.

In SynchronizedModeGamePlayback, now handling NEXT_BLOCK_AFTER_FIN in the same
way that we're already handling NEW_BLOCK_STARTS. This is an extremely simple
change. Just reporting to m_nextBlkListener the additional information.