This file is just a vague attempt to remind me which bytes mean what!
-------------------------------------------------------------------------------------
-> Graphics/Sprites
None of these are compressed in any way in ROM. The bytes are packed together snugly
if there are less than 4 bitplanes - If an 8x8 sprite only uses one bitplane, it is
held as 8 bytes. You would have to expand each byte to 4 bytes when copying to VRAM.
-------------------------------------------------------------------------------------
-> Paths
Some of the enemy attack patterns follow precalculated paths (small red balls, for
example, follow a simple loop). The data is held in the following format:

	BYTES   sX, sY
	NIBBLES dX, dY   #1
	NIBBLES dX, dY   #2
	....... ..  .. ....
	NIBBLES dX, dY #256

That is, each path has a starting X point and starting Y point, followed by UP TO 256
bytes of movement data. A movement value of $FF signifies "end of path".
Each byte of movement data is made up of a pair of nibbles. The least significant
nibble controls the X position of the sprite, the most significant the Y.
If the nibble is moving the object LEFT or UP, then the most significant bit of that
nibble is set. For example:

	%0001 - move right/down 1 pixel
	%0011 - move right/down 3 pixels
	%1001 - move left/up 1 pixel
	%1100 - move left/up 4 pixels
-------------------------------------------------------------------------------------
-> Levels
Each is made up of a number of 20-tile-wide spans.
Each span is compressed using RLE (with a flag character of $FF).
-------------------------------------------------------------------------------------
-> Sound effects
Each is a list -
WORD = Frequency of tone + start volume:
       1 1 V V V V F F, F F F F F F F F
BYTE = Length of tone in frames
BYTE = Amount to increment volume by per frame (in sixteenths)
BYTE = Amount to increment period by per frame
... followed by the byte 0.
-------------------------------------------------------------------------------------
-> Sound effects in memory at runtime
Each is stored in 10 bytes:
WORD +0 sound_pos	Where in memory is the current sound effect?
BYTE +2 sound_time	Decay of current sound effect
BYTE +3 sound_vol	Volume level of current sound effect
BYTE +4 sound_priority	Priority of the current sound effect
WORD +5 sound_freq	Frequency of the current sound effect
WORD +7 sound_freq_chg	Frequency change/frame
BYTE +9 sound_vol_chg	Volume change/frame (16ths)
-------------------------------------------------------------------------------------
-> Scores
Scores are held in a 8-byte BCD variable.
That it is to say, each byte is a digit. .db 1,4,3,5 = 1435.
-------------------------------------------------------------------------------------
-> Enemies
Enemies are held in 8 byte chunks, following this format:

	S,X,Y,D,D,D,D,D

X is the X coordinate, Y is the Y coordinate. S is the sprite index. The remaining 5
bytes marked D are anything you want them to be (ala ZOMBOCOM)
If the sprite index is set to 0, the enemy is regarded as being DISABLED.

For paths:
	ix+3 -- How far along the path are we?
	ix+5 \_ Address of path we're moving along
	ix+4 /

For attackers:
	ix+3 -- DX
	ix+4 -- DY
	ix+5 -- Hover period

For fast sine/normal sine:
	ix+4 \_ Address of sine wave
	ix+3 /
	ix+5 -- X-offset
	ix+6 -- Angle of sine wave

For drifters:
	ix+3 -- Clock
-------------------------------------------------------------------------------------
-> Attack tables
Single zero-terminated list of 4 byte chunks, each chunk made up of:
BYTE +0 Sprite index of enemy
BYTE +1 Delay (in frames) between adding the enemies
BYTE +2 How many enemies of this type will be added
BYTE +3 Delay after adding last enemy
WARNING: Owing to lazy coding, the first attack MUST have more than 1 enemies!
A pseudo-code version might look like:

pointer = start_of_attack_table
do
	for (enemy = 1 to [pointer+2]) :
		add enemy ([pointer+0])
		delay ([pointer+1])
	end for
	delay ([pointer+3])
	pointer += 4
	if [pointer+0] is 0 :
		pointer = start_of_attack_table
	end if
loop