/*
 * This work was originally done by Fred Taft (fred_taft@hp.com).
 * Please forward any comments, corrections or additions back to Fred.
 *
 * Note that the work here is incomplete.  If you have the time to work
 * further on this, please repost your results, so that the rest of us
 * can benefit from your knowledge.
 *
 * Dark Tower
 *
 ******************************************************************************
 ******************************************************************************
 *
 * The following is the memory map for Dark Tower RAM usage:
 *
 * C880		The console button mask.
 *
 * C881-C882	Joystick enable flags.
 *
 * C883		Work memory, when player is in forest.
 *
 * C884		Work memory, when player is in forest.
 *
 * C883-C884	Has many uses:
 *
 *			1) During brigand drawing, C883 holds a copy of the
 *			   drawing intensity, while C884 holds a copy of the
 *			   scale factor.
 *
 * C884-C885	Has many uses:
 *
 *			1) Used during fog and plague drawing, to indicate 
 *			   where to draw the fog/plague lines.
 *
 * C883-C886	Used as work memory, during the generation of the solution
 *		to the puzzle; keeps track of which keys have already been
 *		used, so that the key will not be used again.  See Note 1.
 *
 * C885-C886	Has many uses:
 *
 *			1) During brigand drawing, holds a pointer to the
 *			   16-bit y and 16-bit x location where the brigand
 *			   is to be drawn.
 *
 *			2) Appears to hold some (y,x) info during normal use.
 *			   Possibly the player's position.
 *
 * C889		Has many uses:
 *
 *			1) Used during generation of forest data.
 *
 *			2) Used during drawing of dot lists; contains a value
 *			   used during the calculation of the scale factor
 *			   and intensity values.
 *
 * C88A		Has man uses:
 *
 *			1) Used during generation of forest data.
 *
 *			2) Used to index into the array of dot lists [CB71]; 
 *			   controls which set of dots is drawn.  Also used 
 *			   when calculating the scale factor and intensity 
 *			   value used to draw the dots.
 *
 * C88B		Used as a loop counter by InvokeRandomFunctionFromTable().
 *
 * C88F
 *
 * C890		Has many uses:
 *
 *			1) During brigand scenes, used to temporarily hold
 *			   the brigand animation index.
 *
 *			2) During inventory request, holds index into player's
 *			   array of possessions.
 *
 *			3) At various times, used as a loop counter.
 *
 * C89C		Startup delay counter.  Controls the length of time the
 *		"REPLACEMENT WARRIOR" or "YOUR FIRST WARRIOR" message
 *		stays up, each time you start up. This is used to control the
 *		invocation of the function whose pointer has been placed into
 *		C89D.
 *
 * C89D-C89E	Function pointer; invoked only when delay timer C89C
 *		decrements from 1 to 0.
 *
 * C89F		Delay counter; filled with random number, and decremented
 *		until it reaches 0.  This is used to control the invocation
 *		of the function whose pointer has been placed into C8A0.
 *
 * C8A0-C8A1	Function pointer; invoked only when delay timer C89F
 *		decrements from 1 to 0.
 *
 * C8A2		Delay counter; filled with random number, and decremented
 *		until it reaches 0.  This is used to control the invocation
 *		of the function whose pointer has been placed into C8A3.
 *
 * C8A3-C8A4	Function pointer; invoked only when delay timer C8A2
 *		decrements from 1 to 0.
 *
 * C8A8		Filled with random number in range 0-7; certain processing
 * 		is disabled if this value is not 0.
 *
 * C8A9		Filled with random number in range 0-3; certain processing
 * 		is disabled if this value is not 0.
 *
 * C8AA		Filled with random number in range 0-1; certain processing
 * 		is disabled if this value is not 0.
 *
 * C8AB-C8AC	Stores intensity and scale values used by Draw2VectorLists().
 *
 * C8AD-C8AE	Stores pointer to an alternate vector list, used by
 *		Draw2VectorLists() and Draw2VectorLists_16bit().
 *
 * C8AF-C8B0	Stores pointer to an alternate vector list, used by
 *		Draw2VectorLists() and Draw2VectorLists_16bit().
 *
 * C8B1		Boolean: indicates if this is the first warrior being
 *		used (0x00) or a replacement warrior (0xFF).
 *
 * C8B2		Players direction of travel; manipulated bases on how the
 *		joystick is moved.  Values are:
 *
 *			0-7   = North
 *			8-15  = NorthWest
 *			16-23 = West
 *			24-31 = SouthWest
 *			32-39 = South
 *			40-47 = SouthEast
 *			48-55 = East
 *			56-63 = NorthEast
 *
 * C8B3		Related to C8B2; set, but never referenced.
 *
 * C8B4-C8B5	Player's 16-bit y position (in forest coordinates).
 *
 * C8B6-C8B7	Player's 16-bit x position (in forest coordinates).
 *
 * C8B8		8-bit y position (in forest coordinates) last used
 *		to generate the forest information.
 *
 * C8B9		8-bit x position (in forest coordinates) last used
 *		to generate the forest information.
 *
 * C8BA-C8BB	16-bit rise (y delta) added or subtracted from player's
 *		current position (in forest coordinates), when player is 
 *		moved; is calculated based on the direction the player is 
 8		moving.
 *
 * C8BC-C8BD	16-bit run (x delta) added or subtracted from player's
 *		current position (in forest coordinates), when player is 
 *		moved; is calculated based on the direction the player is 
 *		moving.
 *
 * C8BE		Boolean: 0 when player is just starting to walk; 1 if
 *		player is already walking.
 *
 * C8BF		Boolean: 0 if player is in the forest, non-zero if the
 *		player is in a treasure chest.
 *
 * C8C0
 *
 * C8C1
 *
 * C8C4-C8C5	Sin  based on player's direction of travel.
 *
 * C8C6-C8C7	Cosine based on player's direction of travel.
 *
 * C8C8		X scalar value tranformed by TransformPoint();
 *
 * C8C9		
 *
 * C8CA		Y scalar value transformed by TransformPoint().
 *
 * C8CB
 *
 * C8D2		When the player is in the forest, indicates the number of
 *		visible objects.
 *
 * C8D3		Boolean: set to 1 when player runs out of warriors, and
 *		game is over.
 *
 * C8D4		Game restart counter; automatically restarts new game when
 *		it decrements to 0.
 *
 * C8D6-C8DF	Array used to track which objects the player has in his
 *		possession.  This is used when the magician attempts to
 *		award the player something new, and also when the player's
 *		inventory is displayed.  An entry will be non-zero if the
 *		player has it in his possession.  See Note 4.
 *
 * C8E0		Intensity adjustment value for special object currently
 *		in view.
 *
 * C8E1-C8E2	Stores a pointer to one of the entries in the 'forest
 *		data' array (C9A6-CA47).  This is the entry representing
 *		the special object currently in view.
 *
 * C8E3-C8E4	Stores a pointer to one of the entries in the 'visible
 *		object' array (CA48-CB07).  This is the entry representing
 *		the special object currently in view.
 *
 * C8E5-C8E6	Pointer to the byte in the array stored at 0xC8F8, which
 *		is associated with the special object currently in sight.
 *
 * C8E7		Holds a bitmask (with only a single bit set), which
 *		represents the special object in view.  When the object
 *		is consumed, this mask is OR'ed with the byte pointed to
 *		by 0xC8E5-0xC8E6.
 *
 * C8E8		Holds a flag which indicates whether the special object
 *		in view has already been consumed, and thus, should not
 *		again be drawn (i.e. bags of gold).  0 => not consumed,
 *		while non-zero => already consumed.
 *
 * C8E9		When the player is entering a treasure chest, used to hold
 *		a random number in the range 6-9.
 *
 * C8EA		When the player encounters a special object in the forest,
 *		this is used as a decrement counter, to allow the enlarging
 *		string to continue to display for a while, after it has
 *		finished enlarging.
 *
 * C8EB		Indicates if the player is alive (0xFF) or has just died (0x00).
 *
 * C8EC-C8ED	Player's 16-bit y position (in screen coordinates: 0x80-0x7F).
 *
 * C8EE-C8EF	Player's 16-bit x position (in screen coordinates: 0x80-0x7F).
 *
 * C8F0		Scale adjustment factor.
 *
 * C8F1		Line drawing pattern used when drawing the player; usually
 *		set to 0xFF (solid lines), but is assigned a random value
 *		when the player is hit by a plague.
 *
 * C8F3-C8F4	Pointer to the label representing the object just awarded
 *		to the player.  Used by the function which draws an
 *		enlarging string.
 *
 * C8F5-C8F6	(y,x) position to display the label of the awarded object.
 *
 * C8F7		During string enlargement, this indexes into the array
 *		of height/width values, used to successively draw the
 *		string larger.
 *
 * C8F8-????	Has multiple uses:
 *
 *			1) Byte array, containing information about which
 *			   consumable objects have already been picked up
 *			   by the player.  When a bit is turned on, it
 *			   indicates that the object has already been
 *			   consumed.
 *
 *			2) Used as a work buffer, after player solves the 
 *			   riddle of the keys.
 *
 * C978-C99C	Array of 18 entries, each 2 bytes long.  Used to store
 *		important forest information (bytes 8 and 9 of the forest
 *		array at C9A6-CA47), when the player temporarily leaves the
 *		forest to enter a treasure chest, or attempts to solve the
 *		riddle of the keys.  When the player returns to the forest,
 *		this information is copied back into the forest array.
 *		These two bytes represent the dynamic (versus the static)
 *		forest data; that is why they must be saved off.
 *
 * C99C-C99F	4 byte array, holding the official solution to the puzzle.
 *		See Note 2 for an explanation of the values.
 *
 * C9A0		Has many uses:
 *
 *			1) Boolean: when player is in the forest, signals
 *			   whether a fog is starting up (0x01), 
 *			   finishing (0x80) or not in effect (0x00).
 *
 *			2) Boolean: when player is fighting brigands in a
 *			   chest, indicates whether any brigands were
 *			   processed during this pass (0xFF).
 *
 *			3) When player is in a chest and meets a magician,
 *			   holds the animation index used to index into an
 *			   array of vector lists, while drawing the magician.
 *
 * C9A1		Has many uses:
 *
 *			1) Controls duration of fog effect.
 *
 *			2) Used during brigand sequence, to indicate whether
 *			   the current brigand has been hit (0xFF).
 *
 * C9A2		Has many uses:
 *
 *			1) Boolean: when player is in the forest, signals
 *			   whether a plague is starting up (0x01), 
 *			   finishing (0x80) or not in effect (0x00).
 *
 *			2) Used to store the angle of fire, when player
 *			   throws a flamoid, while in a chest.
 *
 * C9A3		Has many uses:
 *
 *			1) Controls duration of plague effect.
 *
 *			2) Used during brigand sequence.
 *
 * C9A0-C9A3	Used to hold the player's guess at the solution to the
 *		puzzle.  See Note 3.
 *
 * C9A4		During player's attempt to solve the puzzle, this contains
 *		the index into the player's solution array (C9A0-C9A3); it
 *		indicates the current key position the player is working on.
 *
 * C9A4-C9B6	When the player is fighting a brigand, this buffer is used
 *		to hold the transformed flamoid vector list.
 *
 * C9A4-C9A5	When the player is in the forest, this is used as a
 *		decrement counter; when it decrements to zero, a plague
 *		occurs.
 *
 * C9A6-CA47    Array of 18 entries, each 9 bytes long.  When the player is
 *		in the forest, this array contains the data describing the
 *		visible trees in the forest.  See Note 10.
 *
 * C9A4-C9B6	When player is in a chest, fighting a brigand, this is used 
 *		to hold the transformed flamoid vector list.
 *
 * C9E0-C9F7    Array of 6 entries, each 4 bytes long.  There are 6 possible
 *		brigands which can appear; each entry in this array represents
 *		one of the possible brigands.  This structure is initialized
 *		by copying the original structure, which is encoded in the
 *		game ROM at 2DAD.  See Note 7 for details of this structure.
 *
 * C9F8-CA4F    Array of 8 entries, each 11 bytes long.  These are the
 *		flamoid entries; holds information about flamoids thrown
 *		both by the player and the brigands.  Only in use when the
 *		player is in a chest fightin a brigand.  See Note 6 for
 *		details about this structure.
 *
 * CA48-CB07	Array of 32 entries, each 6 bytes long.  When the player is
 *		in the forest, each entry in this array contains information 
 *		about what is visible to the player (trees, gold, keys,
 *		dark tower, treasure chest, etc).  See Note 9.
 *
 * CA50-CB21	Array of 14 entries, each 15 bytes long.  These are the
 *		explosion buffers.  When the player is fighting a brigand,
 *		if the player hits the brigand, or the brigand hits the
 *		player, that person will explode into pieces, which fly
 *		off spinning into different directions.  Each individual
 * 		piece is placed into its own explosion buffer entry.
 *		See Note 5 for details of this structure.
 *
 * CB2C-CB40	Buffer for holding the player's score string; it has the
 *		following format: "YOUR SCORE IS      0",0x80.
 *
 * CB41-CB49	Buffer for holding the player's direction of travel, and
 *		the number of steps taken since the last change of
 *		direction.  It has the following format:
 *		" NE    0",0x80  (for forward movement)  or 
 *		" NE -  1",0x80  (for backward movement).
 *
 * CB4A		Boolean: Indicates if the current step counter (i.e. the
 *		number of steps the player has taken in the current
 *		direction) is 0 (1) or non-zero (0).
 *
 * CB4B-CB5C	Buffer for holding the string indicating the number of
 *		bags of gold the player has.  It has the following format:
 *		"   2 BAGS OF GOLD",0x80.
 *
 * CB5D-CB6B	Buffer used for displaying string indicating the number
 *		of warriors awarded to the player, or the number of bags
 *		of gold awarded to the player.  It has the following format:
 *		"1 NEW WARRIOR",0x80  or  "2 BAGS OF GOLD",0x80.
 *
 * CB6C
 *
 * CB6D
 *
 * CB6E
 *
 * CB6F
 *
 * CB70
 *
 * CB71-CB80	Array of 16-bit pointers; each pointer points to a list
 *		of dot verticies.  This array is initialized by a call
 * 		into the MineStorm code in the ExecOS ROM.
 *
 * CB81-CB88    This is an array of 8 scale factors.  The scale factors
 *              are used when the corresponding set of motion dots (see
 *              above entry) are drawn.
 *
 * CB89		Boolean: indicates whether dot drawing sequence is active.
 *		DrawDotList() clears this when it has finished drawing
 *		the animated dot sequence:
 *
 *			0x00  => Dot sequence complete/inactive
 *			> 0   => Scale adjustment factor will be increased
 *				 over time.
 *			< 0   => Scale adjustment factor will be decreased
 *				 over time.
 *
 * CB8A		Scale adjustment value, used during dot drawing.
 *
 * CB8C-CB9F	Buffer for holding the string indicating the number of
 *		reserve troops the player has.  It has the following
 *		format: "   6 RESERVE TROOPS",0x80.
 *
 ******************************************************************************
 *
 * NOTES:
 * ------
 *
 * Note 1:	Keys Already Used Array
 *
 *		      -------------------
 *		C883  | Gold key used   |
 *		      -------------------
 *		C884  | Silver key used |
 *		      -------------------
 *		C885  | Bronze key used |
 *		      -------------------
 *		C886  | Brass key used  |
 *		      -------------------
 *
 * Note 2:	Official Solution To The Puzzle
 *
 *		      ---------
 *		C99C  | Key 1 |
 *		      ---------
 *		C99D  | Key 2 |
 *		      ---------
 *		C99E  | Key 3 |
 *		      ---------
 *		C99F  | Key 4 |
 *		      ---------
 *
 *		The value for each key is one of the following:
 *
 *			1 = Gold key
 *
 *			2 = Silver key
 *
 *			3 = Bronze key
 *
 *			4 = Brass key
 *
 * Note 3:	Player's Guess At Solution
 *
 *		      ----------------
 *		C9A0  | Key 1 guess  |
 *		      ----------------
 *		C9A1  | Key 2 guess  |
 *		      ----------------
 *		C9A2  | Key 3 guess  |
 *		      ----------------
 *		C9A3  | Key 4 guess  |
 *		      ----------------
 *
 *		The value for each guess is one of the following:
 *
 *			0 = No guess (initial state)
 *
 *			1 = Gold key
 *
 *			2 = Silver key
 *
 *			3 = Bronze key
 *
 *			4 = Brass key
 *
 * Note 4:	Items In Player's Possession
 *
 *		      --------------------------
 *		C8D6  | Gold Key               |
 *		      --------------------------
 *		C8D7  | Silver Key             |
 *		      --------------------------
 *		C8D8  | Bronze Key             |
 *		      --------------------------
 *		C8D9  | Brass Key              |
 *		      --------------------------
 *		C8DA  | Crystal Crown          |
 *		      --------------------------
 *		C8DB  | Scout                  |
 *		      --------------------------
 *		C8DC  | Healer                 |
 *		      --------------------------
 *		C8DD  | # of bags of Gold      |
 *		      --                      --
 *		C8DE  |                        |
 *		      --------------------------
 *		C8DF  | # Replacement warriors |
 *		      --------------------------
 *
 * Note 5:	Explosion Buffer
 *
 *		   --------------------------
 *		0  | In use Flag 0/1        |
 *		   --------------------------
 *		1  | Rise (y) Delta         |
 *		   --                      --
 *		2  |                        |
 *		   --------------------------
 *		3  | Run (x) Delta          |
 *		   --                      --
 *		4  |                        |
 *		   --------------------------
 *		5  | 16-bit Y position      |
 *		   --                      --
 *		6  |                        |
 *		   --------------------------
 *		7  | 16-bit X position      |
 *		   --                      --
 *		8  |                        |
 *		   --------------------------
 *		9  | Scale Factor           |
 *		   --------------------------
 *		A  | Angle of travel        |
 *		   --------------------------
 *		B  | Angle delta (spin rate)|
 *		   --------------------------
 *		C  | Vector list pointer    |
 *		   --                      --
 *		D  |                        |
 *		   --------------------------
 *		E  | Lifespan               |
 *		   --------------------------
 *
 *		The lifespan field controls how long the object gets drawn.
 *		When it decrements to 0, the entry gets marked as no longer
 *		in use.
 *
 * Note 6:	Flamoid Buffer
 *
 *		   --------------------------
 *		0  | In use Flag 0/1        |
 *		   --------------------------
 *		1  | Rise (y) Delta         |
 *		   --                      --
 *		2  |                        |
 *		   --------------------------
 *		3  | Run (x) Delta          |
 *		   --                      --
 *		4  |                        |
 *		   --------------------------
 *		5  | 16-bit Y position      |
 *		   --                      --
 *		6  |                        |
 *		   --------------------------
 *		7  | 16-bit X position      |
 *		   --                      --
 *		8  |                        |
 *		   --------------------------
 *		9  | ??????                 |
 *		   --------------------------
 *		A  | Lifespan               |
 *		   --------------------------
 *
 *		The lifespan field controls how long the object gets drawn.
 *		When it decrements to 0, the entry gets marked as no longer
 *		in use.
 *
 * Note 7:	Soft Brigand Data
 *
 *		   --------------------------
 *		0  | Current state          |
 *		   --------------------------
 *		1  | Animation index        |
 *		   --------------------------
 *		2  | Pointer to Hard Brigand|
 *		   --                      --
 *		3  | Data      (See Note 8) |
 *		   --------------------------
 *
 *		This structure contains the 'soft' data associated with a
 *		brigand.  It is soft because it can change over the course
 *		of the game.

 *		The current state can assume one of the following values:
 *
 *			0x80 = In use
 *			0x40 = Flamoid has been thrown
 *			0x01 = Inactive
 *
 *		The Animation index starts at 0, and increments upto 0x15.
 *		It is used to index into the array of brigand images, and
 *		controls which image is drawn, when a flamoid is thrown, and
 *		when the brigand is vulnerable to being hit by the player's
 *		flamoids.
 *
 * Note 8:	Hard Brigand Data
 *
 *		   --------------------------
 *		0  | Brigand's 16-bit Y     |
 *		   --                      --
 *		1  | Position               |
 *		   --------------------------
 *		2  | Brigand's 16-bit X     |
 *		   --                      --
 *		3  | Position               |
 *		   --------------------------
 *		4  | Flamoid's 16-bit Y     |
 *		   --                      --
 *		5  | Position               |
 *		   --------------------------
 *		6  | Flamoid's 16-bit X     |
 *		   --                      --
 *		7  | Position               |
 *		   --------------------------
 *		8  | ????                   |
 *		   --------------------------
 *		9  | ????                   |
 *		   --------------------------
 *		0A | ????                   |
 *		   --------------------------
 *		0B | ????                   |
 *		   --------------------------
 *		0C | ????                   |
 *		   --------------------------
 *		0D | Image Flip Flag        |
 *		   --------------------------
 *		0E | Scale Factor           |
 *		   --------------------------
 *		0F | Target Size (height/2) |
 *		   --                      --
 *		10 | Target Size (width/2)  |
 *		   --------------------------
 *
 *		This structure contains the brigand data which is fixed, and
 *		the only copy is stored in the game ROM.  There is one entry
 *		for each of the 6 possible brigands.  The 'Image Flip Flag'
 *		indicates whether the associated brigand vector list should
 *		be flipped around the y axis; this allows a single vector
 *		list to be used for a brigand coming from either the left
 *		or right side of a wall.
 *
 * Note 9:	Visible Objects In The Forest
 *
 *		   ------------------------------
 *		0  | Visible Object Id          |
 *		   ------------------------------
 *		1  | 8-bit y position           |
 *		   ------------------------------
 *		2  | 8-bit x position           |
 *		   ------------------------------
 *		3  | Intensity adj value        |
 *		   ------------------------------
 *		4  | Pointer to entry in        |
 *		   --                          --
 *		5  | the forest array (Note 10) |
 *		   ------------------------------
 *
 *		This structure contains the information describing a visible
 *		object in the forest (tree, treasure chest, gold, key, etc).
 *
 *		The Visible Object Id not only identifies the object, but
 *		also, in some cases, the lower 4 bits are used as an index
 *		into the a jump table, whose entries represent the function
 *		used to award the given object.  The Visible Object Id can
 *		assume the following values:
 *
 *			0x00 => nothing
 *			0x01 => a tree
 *			0x8x =>
 *			0x9x =>
 *			0xF4 => Dark Tower
 *			0xF2 => Gold
 *			0xF0 => Key
 *			?????
 *
 *
 * Note 10:	Forest Information
 *
 *		   ----------------------------------
 *		0  | Id or vector list pointer      |
 *		   --                              --
 *		1  |                                |
 *		   ----------------------------------
 *		2  | 16-bit Y Information           |
 *		   --                              --
 *		3  |                                |
 *		   ----------------------------------
 *		4  | 16-bit X Information           |
 *		   --                              --
 *		5  |                                |
 *		   ----------------------------------
 *		6  | Image flip flag                |
 *		   ----------------------------------
 *		7  | Object state                   |
 *		   ----------------------------------
 *		8  | Treasure chest animation index |
 *		   ----------------------------------
 *
 *		The 'Object state' field starts at 0, and basically acts
 *		like the 'controller' for a mini state machine.  When the
 *		player encounters an object in the forest, this is used
 *		to control the object as it transitions through a series 
 *		of animations as the user is taking procession of the object.
 *
 *		If byte 0 is 0x00, then byte 1 contains the Id of a special
 *		object; otherwise, bytes 0 & 1 are a pointer to a tree
 *		vector list.
 *
 ******************************************************************************
 */

	include "osmapV3.h"
	include "fnmapV3.h"

	org 0x0000 
S0000: db    "g GCE 1983",0x80 
       dw    DT_IntroMusic 
       db    0xF8 
       db    0x50 
       db    0x40 
       db    0xE0 
       db    "DARK",0x80 
       db    0xF8 
       db    0x50 
       db    0x20 
       db    0xD8 
       db    "TOWER",0x80,0x00 

StartNewGame:
       jsr   DPRAM   
	direct $C8
       inc   $C824 
       ldd   #0x0004       ; Support 1 player & 4 games 
       jsr   SELOPT
       jsr   DPRAM   
	direct $C8
       lda   #0xEE         ; Save console button mask 
       sta   $C880 
       ldx   #0x0103 
       stx   $C881        ; Save joystick enable flags 
       ldx   #0xC883       ; Clear all game controlled 
P003B: clr   ,x+           ; RAM; C883 - CBE9.         
       cmpx  #0xCBEA 
       bne   P003B 
       jsr   MS_INIT_MOTION_DOTS
       ldd   #0x1000       ; Set restart counter, for when 
       std   $C8D4        ; after the game ends. 
       dec   $C87A        ; Force game # in range 0 - 3 
       ble   P005F         ; Jump if game 1 selected 
       jsr   AwardSilverKey 
       dec   $C87A 
       ble   P005F         ; Jump if game 2 selected 
       jsr   AwardBronzeKey 
       dec   $C87A 
       ble   P005F         ; Jump if game 3 selected 
       jsr   AwardBrassKey 
P005F: ldx   #YourScoreIsLabel   ; Make copy of string 
       ldu   #0xCB2C 
       jsr   CopyStringToBuffer 
       ldd   #0x0500 
       std   $C9A4        ; Set plague delay counter 
       ldd   #CheckForDeadPlayer 
       std   $C89D        ; Set indirect jump pointer 
       lda   #0x1F 
       sta   $C89C        ; Set startup delay counter 
       ldd   #ActivateABrigand 
       std   $C8A0        ; Set indirect jump pointer 
       lda   #0x06 
       sta   $C8DF        ; Start player with 6 warriors 
       ldx   #ReserveTroopsLabel 
       ldu   #0xCB8C 
       jsr   CopyStringToBuffer 
       ldd   #0x0002       ; Start player with 2 bags of 
       std   $C8DD        ; gold. 
       ldx   #BagsOfGoldLabel_2 
       ldu   #0xCB4B 
       jsr   CopyStringToBuffer 

       ; Calculate where to place the player 
P0097: jsr   PlacePlayerRandomlyInForest 
       lda   $C8B6        ; If the random position doesn't 
       asla                ; fall into an acceptable 
       anda  #0x40         ; range, then discard these 
       ora   $C8B4        ; values, and try again. 
       anda  #0x60         ; This may be preventing the 
       beq   P0097         ; player from starting in a 
                           ; non-forested area. 

       ; Calculate solution to 'Riddle Of The Keys' 
       ldx   #0xC882      ; This array is used to keep 
       ldd   #0x0000      ; track of which keys have  
       std   $C883         ; already been used; can't use 
       ; FDT: BUG  should be 0x85!! 
       std   $C884         ; keys more than once. 
       jsr   RANDOM
       anda  #0x03        ; Generate random number (1-4) 
       inca               ; representing index of first 
       sta   $C99C       ; key. 
       sta   $C88F 
       inc   a,x          ; Tag key as now in use 
P00BC: jsr   RANDOM
       anda  #0x03        ; Generate random number (1-4) 
       inca               ; representing index of second 
       sta   $C99D       ; key. 
       ldb   a,x 
       bne   P00BC        ; Redo, if already in use. 
       inc   a,x          ; Tag key as now in use 
       adda  $C88F 
       sta   $C88F 
P00CF: jsr   RANDOM
       anda  #0x03        ; Generate random number (1-4) 
       inca               ; representing index of third 
       sta   $C99E       ; key. 
       ldb   a,x 
       bne   P00CF        ; Redo, if already in use 
       inc   a,x          ; Tag key as now in use 
       adda  $C88F 
       sta   $C88F       ; Since the sum of all of the 
       lda   #0x0A        ; key indices is '10', the last 
       suba  $C88F       ; key index is easy to calculate. 
       sta   $C99F        ; Set index of last key 

       ; This is the game's main loop 
MainLoop:
       jsr   CheckForInventoryRequest 
       pshs  dp 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       lda   $C89C       ; When the startup delay counter 
       bne   P00F9        ; hits 0, set C8B1, so next time 
       coma               ; we use 'Replacement Warrior', 
       sta   $C8B1       ; instead of 'Initial Warrior'. 
P00F9: jsr   ProcessMovementAndDrawPlayer 
       clr   $C8BF       ; Flag that player's in forest 
       jsr   ProcessForestObjects 
       ldx   $C9A4       ; If not already 0, then 
       beq   P010B        ; decrement the plague delay 
       leax  -1,x         ; counter 
       stx   $C9A4 
P010B: puls  dp 
	direct $D0
       lda   $C89C       ; Keep showing 'Warrior' string 
       beq   P012F        ; until startup delay elapses. 
       lda   $C8B1       ; Is this the 'Initial' or a 
       bne   P011C        ; 'Replacement' warrior? 
       ldu   #YourFirstWarriorLabel 
       bra   P0129 
P011C: lda   $C9A3 
       bne   P012F       ; Skip, if plague is in effect 
       lda   $C8DF     ; If no replacement warriors left, 
       beq   P012F       ; then the game is over. 
       ldu   #ReplacementWarriorLabel 
P0129: jsr   INTMAX
       jsr   PrintMultiPartString 
P012F: jsr   CheckIfFogActive 
       jsr   CheckIfPlagueIsActive 
       jsr   CheckForGameOver 
       bra   MainLoop 

; ProcessForestObjects()
;
; If there is currently a special object in view, then it
; it query information about whether or not the object has
; already been consumed.  It will then check to see if
; the player is close to a treasure chest, and whether or
; not the player is asking to enter the treasure chest.
        
ProcessForestObjects:
       pshs  dp 
	direct $C8
       ldy   $C8E1           ; Is a special item in view? 
       beq   DrawForestScene  ; Nope 
       jsr   CheckIfObjectConsumed  ; Yep; see if consumed 
       sta   $C8E8           ; Save 'been consumed flag 
       ldd   $C883           ; Get ptr to 'consumed' byte 
       std   $C8E5           ; Save ptr to 'consumed' byte 
       lda   $C885           ; Get obj's 'consumed' bitmask
       sta   $C8E7           ; Save the 'consumed' bitmask 
       lda   $C815           ; Get btn4 state; does player 
       beq   DrawForestScene  ; want 2 grab special item? 
       lda   [ $C8E3 ]       ; Yep; get object's Id 
       anda  #0xE0            ; Skip, if this is not a 
P0158: cmpa  #0x80            ; treasure chest object. 
       bne   DrawForestScene 
       lda   $C8EB           ; Is player dead? 
       beq   DrawForestScene  ; Skip, if player is dead 
       lda   $C9A0           ; If the player is in the 
       ora   $C9A2           ; middle of fog or plague, 
       ora   $C856            ; or if some sound is active, 
       bne   DrawForestScene  ; then jump elsewhere. 
       lda   7,y              ; Determine whether what 
       bita  #0x02            ; state this object is 
       bne   P0183            ; currently in. 
       bita  #0xFE 
       bne   DrawForestScene 
       lda   #0x03           ; Init treasure chest state 
       sta   7,y             ; Set initial state for object 
       lda   #0x01 
       sta   8,y             ; Init animation index 
       lda   #0x30 
       sta   $CB6D 
       bra   P0187 
P0183: lda   #0x05           ; Force treasure chest to 
       sta   7,y             ; next state. 
P0187: clr   $C815          ; Clear console 1, btn4 state 

; DrawForestScene()
;
; Displays the direction/step information, along with
; drawing each currently visible object.
        
DrawForestScene:
       lda   #0xD0 
       tfr   a,dp 
	direct $D0
       jsr   INTMAX
       ldd   #0xFB38 
       std   $C82A       ; Set string height & width 
       ldd   #0x7F10      ; Set (y,x) position 
       jsr   POSITD
       ldu   #0xCB41      ; Display direction of travel 
       jsr   RASTER
       ldu   #0xCA48      ; Get ptr to tree position data 
       lda   #0x20 
       sta   $C8CF       ; Set loop counter 
       lda   #0xFF 
       sta   $C829       ; Set line drawing pattern 
P01AF: ldy   4,u 
       lda   0,u 
       beq   P01DE        ; Skip, if entry is inactive 
       bmi   ObjectIsSpecial 
       lda   6,y 
       sta   $CBA0       ; Control flipping of image 
       lda   #0x7F        ; Calculate the intensity to 
       suba  3,u          ; be used; if it comes out 
       sta   $C883       ; < 0x20, then don't draw. 
       adda  #0x30        ;   int=0x7F-(3,u)+0x30-$C9A1 
       bvc   P01CA        ; Check for calculation overflow 
       lda   #0x7F        ; Max intensity is 0x7F 
P01CA: suba  $C9A1 
       cmpa  #0x20        ; Draw tree only if close 
       ble   P01DE        ; enough to be visible. 
       ldb   $C883       ; Calculate scale factor: 
       lsrb               ;    ((0x7F-(3,u))/2)+8 
       addb  #0x08        
       ldx   0,y          ; Get ptr to vector list 
       leay  1,u          ; Get ptr to 8-bit position 
       jsr   DT_MoveThenDraw 
P01DE: leau  6,u          ; Get ptr to next tree pos entry 
       dec   $C8CF       ; Decrement loop counter 
       bne   P01AF        ; Process next entry 
       puls  dp,pc        ; All done 

; Object is a treasure chest, gold, key, Dark Tower, etc 
ObjectIsSpecial:
       lda   0,u        ; Determine which object this is 
       cmpa  #0xF2      ; Is it a bag of gold? 
       lbeq  ProcessBagsOfGoldInForest 
       cmpa  #0xF0      ; Is it a key? 
       lbeq  ProcessKeysInForest 
       cmpa  #0xF4      ; Is it the Dark Tower? 
       lbeq  ProcessDarkTowerInForest 
       anda  #0xF0 
       cmpa  #0xE0 
       beq   P01DE 
       lda   $C8EC     ; Get player's y position 
       ldb   $C8EE     ; Get player's x position 
       jsr   DrawDotsIfActive 
       sta   $C8F0 
       lda   7,y 
       anda  #0x3E 
       ora   $C8BF 
       sta   $C8BF 
       lda   7,y           ; Check the state of the object 
       bita  #0x30         ; Are we in the handler? 
       bne   InvokeChestAction  ; Yep 
       bita  #0x08         ; Are we delaying? 
       bne   CheckDelay    ; Yep 
       bita  #0xFE         ; Are we drawing static chest? 
       beq   DrawTreasureChest  ; Yep 
       ldb   $C8A8        ; 'Slow down' flag disabled? 
       bne   DrawTreasureChest  ; Nope, so don't update. 
       bita  #0x04         ; Is the chest closing? 
       bne   ChestClosing  ; Yep 
       lda   8,y           ; Use the treasure chest 
       inca                ; animation index to get the 
       asla                ; correct treasure chest base. 
       ldx   #TreasureChestBase_Table 
       ldx   a,x           ; If the vector list is 0x0000, 
       beq   InitDelayCounter  ; then animation is complete 
       lsra                ; Update the treasure chest 
       sta   8,y           ; animation index. 
       bra   DrawTreasureChest 
ChestClosing:
       dec   8,y           ; Decrement animation index 
       bne   DrawTreasureChest 
       lda   #0x01         ; Set state to show that the 
       sta   7,y           ; chest has finished closing. 
       bra   DrawTreasureChest 
InitDelayCounter:
       lda   #0x09         ; Set object state to show we're 
       sta   7,y           ; waiting on the delay counter. 
       lda   #0x08         ; Set delay counter; controls 
       sta   $C8EA        ; when chest action is invoked. 
CheckDelay:
       dec   $C8EA        ; Wait for delay counter to 
       bne   DrawTreasureChest  ; decrement to 0. 
InvokeChestAction:
       ldx   #ObjectTbl ; Invoke the action corresponding 
       lda   0,u        ; to the object encountered. 
       anda  #0x0E 
       jsr   [ a,x ]    ; (INDIRECT JUMP) 
DrawTreasureChest:
       lda   6,y 
       sta   $CBA0     ; Control flipping of image 
       lda   #0x7F      ; Calculate intensity 
       suba  3,u        ; Adjust value, based on some 
       tfr   a,b        ; object information. 
       adda  #0x20      ; Further adjust value 
       bvc   P0270      ; Check for overflow 
       lda   #0x7F      ; Use max intensity value 
P0270: suba  $C9A1     ; More adjustments 
       cmpa  #0x20      ; If the object is too far away 
       lble  P01DE      ; to be seen, then skip it. 
       sta   $C8AB     ; Save intensity value 
       lsrb             ; Calculate scale factor 
       subb  #0x0C      ; Adjust the value 
       lble  P01DE      ; Skip object if scale <= 0 
       stb   $C8AC     ; Save scale factor 
       ldx   #TreasureChestBase_Table 
       lda   8,y        ; Use the treasure chest 
       asla             ; animation index to draw the 
       ldx   a,x        ; correct treasure chest base. 
       stx   $C8AD     ; Set alternate vector list 1 
       ldx   #TreasureChestLid_Table 
       ldx   a,x        ; Get correct treasure chest lid 
       stx   $C8AF     ; Set alternate vector list 2 
       ldd   #0x0000    ; Force drawing of alt vector list 
       leay  1,u        ; Set addr of drawing position 
       jsr   Draw2VectorLists 
       jmp   P01DE 

; When a special object is encountered in the forest, this
; table indicates the function to process the object.  The
; first byte of the 'visible objects in forest' structure
; is used to index into this array.
 
ObjectTbl:
       dw    NoObject 
       dw    GoldOrNewWarriorObject 
       dw    BrigandChestObject 
       dw    MagicianObject 
       dw    FogObject 
       dw    PlagueObject 
       dw    NoObject 
       dw    NoObject 

; GoldOrNewWarriorObject()
;
; Entry: y = ptr to Forest Info structure
;
; This is a mini state machine, where the state is controlled
; by the 8th byte in the structure pointed to by 'y'.
; The state transition is as follows:
;
;	0x0x => Just starting  determine award, start drawing
;             the enlarged string, and set state = 0x11.
;
;	0x1x => Keep drawing enlarging string representing
; 		the prize.  When the scale index (C8F7)
;		used by the enlarging string function reaches
;		0x60, set state = 0x21.
;
;	0x2x => Finish drawing the enlarging string, and
;		once it is completely enlarged, leave it
;		displaying, until C8EA decrements to 0, at
;		which point set state = 0x05.
;
;	0x05 => All done.
 
GoldOrNewWarriorObject:
       lda   7,y 
       bita  #0x20 
       bne   P02F5        ; Goto state 3 processing 
       bita  #0x10 
       bne   P02E2        ; Goto state 2 processing 
       lda   $C8E8       ; Get 'been consumed' flag 
       bne   P0308        ; Skip, if already consumed 
       lda   #0x11        ; State 1: initialize, and 
       sta   7,y          ; set to state 2. 
       pshs  dp,x,y,u 
       lda   #0xC8 
       tfr   a,dp         ; Select random prize to award 
	direct $C8
       ldu   #RandomAwardsTable1 
       jsr   InvokeRandomFunctionFromTable 
       jsr   SetLabelOfFoundObject 
       lda   [ $C8E5 ]   ; Get 'consumed' byte 
       ora   $C8E7       ; Flag object as 'consumed' 
       sta   [ $C8E5 ]   ; Save updated 'consumed' byte 
	direct $D0
       puls  dp,x,y,u 
P02E2: jsr   DrawEnlargingString  ; State 2 
       lda   $C8F7      ; When the enlargement factor 
       cmpa  #0x60       ; reaches 0x60, change to 
       blt   P0307       ; state 3. 
       lda   #0x21       ; Entering state 3 
       sta   7,y 
       lda   #0x1F 
       sta   $C8EA      ; Set delay counter 
P02F5: jsr   DrawEnlargingString  ; State 3 
       dec   $C8EA      ; Has delay counter expired? 
       bne   P0307       ; Nope 
       lda   #0x05       ; Yep; All done 
       sta   7,y         ; Enter state 4 
       ldd   #0x0000 
       std   $C8F3      ; Clear out string pointer 
P0307: rts 

P0308: lda   #0x84 
P030A: sta   0,u 

; BrigandChestObject()
;
; Entry: y = ptr to Forest Info structure
;
; This is a mini state machine, where the state is controlled
; by the 8th byte in the structure pointed to by 'y'.
; The state transition is as follows:
;
;	0x0x => Just starting  initiate the dot sequence used
;             transition the player into the treasure chest,
;	        and set state = 0x11.
;
;	0x1x => Wait for the dot sequence to complete.  Also,
; 		generate a random number in the range 6-9,
;		and store it in C8E9.  When the dot sequence
;		completes, have the player enter the chest,
;		and wait for that to finish.  If the player
;		is still alive, then initiate another dot
;		sequence, to transition him back to the
;		forest.  At that point, set state = 0x21.
;
;	0x2x => When the delay counter (C8EA) decrements
;		to 0, then we're done, so set state = 0x05.
;
;	0x05 => All done.
 
BrigandChestObject:
       lda   7,y 
       bita  #0x20 
       lbne  P03C6         ; Goto state 3 processing 
       bita  #0x10 
       bne   P0324         ; Goto state 2 processing 
       lda   #0x01         ; State 1 
       sta   $CB89        ; Flag start of dot sequence
       clr   $CB8A        ; Clear scale adj factor 
       lda   #0x11 
       sta   7,y           ; Change to state 2 
P0324: lda   $CB89        ; State 2: wait for dot 
       bne   P0357         ; sequence to complete. 
       lda   $C8E9        ; If we have not already 
       bne   P0338         ; done so, then generate 
       jsr   RANDOM        ; a random number in the 
       anda  #0x03         ; range 6-9. 
       adda  #0x06 
       sta   $C8E9        ; Save this number 
P0338: pshs  dp,y,u        ; Process the player in 
       jsr   PlayerEnteringChest  ; the treasure chest; 
       puls  dp,y,u        ; wait for him to finish. 
       lda   #0x21 
       sta   7,y           ; Change to state 3 
       lda   #0x1F         ; If the player is still alive, 
       sta   $C8EA        ; then transition him back into 
       lda   $C8EB        ; the forest. 
       beq   P0357         ; Skip, if player is dead 
       lda   #0x80 
       sta   $CB89        ; Flag start of dot sequence 
       lda   #0x3F 
       sta   $CB8A        ; Set scale adj value 
P0357: rts 

; MagicianObject()
;
; Entry: y = ptr to Forest Info structure
;
; This is a mini state machine, where the state is controlled
; by the 8th byte in the structure pointed to by 'y'.
; The state transition is as follows:
;
;	0x0x => Just starting  initiate the dot sequence used
;             transition the player into the treasure chest,
;	        and set state = 0x11.
;
;	0x1x => Wait for the dot sequence to complete.
;		When the dot sequence completes, have the 
;		player enter the chest, to receive an award
;		from the magician.  Then initiate another dot
;		sequence, to transition him back to the
;		forest.  At that point, set state = 0x21.
;
;	0x2x => When the delay counter (C8EA) decrements
;		to 0, then we're done, so set state = 0x05.
;
;	0x05 => All done.
 
MagicianObject:
       lda   $C8E8        ; Get 'been consumed' flag 
       bne   P0308         ; Skip, if already consumed 
       lda   7,y 
       bita  #0x20 
       bne   P03C6         ; Goto state 3 processing 
       bita  #0x10 
       bne   P0373         ; Goto state 2 processing 
       lda   #0x01         ; State 1 
       sta   $CB89        ; Flag start of dot sequence 
       clr   $CB8A        ; Clear scale adj factor 
       lda   #0x11 
       sta   7,y           ; Change to state 2 
P0373: lda   $CB89        ; Jump if the dot sequence 
       bne   P039D         ; has not completed. 
       lda   [ $C8E5 ]    ; Get 'consumed' byte 
       ora   $C8E7        ; Flag obj as 'consumed' 
       sta   [ $C8E5 ]    ; Save updated 'consumed' byte 
       pshs  dp,y,u        ; Move player into the chest, 
       jsr   InsideMagicianChest  ; and attempt to award 
       puls  dp,y,u        ; him something. 
       lda   #0x21 
       sta   7,y           ; Change to state 3 
       lda   #0x1F         ; Start another dot sequence, 
       sta   $C8EA        ; as we transition the player 
       lda   #0x80         ; back to the forest. 
       sta   $CB89        ; Flag start of dot sequence 
       lda   #0x3F 
       sta   $CB8A        ; Set scale adj value 
P039D: rts 

; FogObject()
;
; Entry: y = ptr to Forest Info structure
;
; This is a mini state machine, where the state is controlled
; by the 8th byte in the structure pointed to by 'y'.
; The state transition is as follows:
;
;	0x0x => Just starting  attempt to force a fog to
;             occur, and then set state = 0x11.
;
;	0x1x => When the delay counter (C8EA) decrements
;		to 0, then we're done, so set state = 0x05.
;
;	0x05 => All done.
 
FogObject:
       lda   7,y 
       bita  #0x10 
       bne   P03C6         ; Goto state 2 processing 
       jsr   TryToStartFog ; State 1 
       lda   #0xFF         
       sta   $C8EA        ; Set duration counter 
       bra   P03C2 

; PlagueObject()
;
; Entry: y = ptr to Forest Info structure
;
; This is a mini state machine, where the state is controlled
; by the 8th byte in the structure pointed to by 'y'.
; The state transition is as follows:
;
;	0x0x => Just starting  attempt to force a plague to
;             occur, and then set state = 0x11.
;
;	0x1x => When the delay counter (C8EA) decrements
;		to 0, then we're done, so set state = 0x05.
;
;	0x05 => All done.
 
PlagueObject:
       lda   7,y 
       bita  #0x10 
       bne   P03C6         ; Goto state 2 processing 
       ldd   #0x0000       ; State 1 
       std   $C9A4        ; Force plague delay to 0 
       jsr   TryToStartPlague 
       lda   #0x4F 
       sta   $C8EA        ; Set duration counter 
P03C2: lda   #0x11         
       sta   7,y           ; Change to state 2/3 
P03C6: dec   $C8EA        ; State 2/3: When the duration 
       bne   P03CF         ; counter has decremented to 0, 
       lda   #0x05         ; change to the 'done' state. 
       sta   7,y 
P03CF: rts 

; NoObject()
;
; Entry: y = ptr to Forest Info structure
;
; This is a mini state machine, where the state is controlled
; by the 8th byte in the structure pointed to by 'y'.
; The state transition is as follows:
;
;	0x0x => Simply initialize the duration counter, and
;             then set state = 0x11.
;
;	0x1x => When the delay counter (C8EA) decrements
;		to 0, then we're done, so set state = 0x05.
;
;	0x05 => All done.
 
NoObject:
       lda   7,y 
       bita  #0x10 
       bne   P03C6        ; Goto state 2 processing 
       lda   #0x10        ; State 1 
       sta   $C8EA       ; Set duration counter 
       bra   P03C2 

; ProcessDarkTowerInForest()
;
; If the player has all of the keys, and is not currently
; in a fog, then this function gives the player the
; chance to try to solve the riddle of the keys.  If the
; player fails to solve the puzzle, then he will be
; placed randomly back into the forest, unless he has a
; scout in his possession, at which point he will simply
; be placed back outside the dark tower.
 
ProcessDarkTowerInForest:
       pshs  dp 
       lda   #0xC8 
	direct $C8
       tfr   a,dp 
       jsr   CheckIfAllKeysAwarded 
       bhs   P0437        ; Branch if not all keys found 
       lda   $C9A0       ; Don't let player solve riddle 
       bne   P040D        ; if he's currently in the fog. 
       lda   [ $C8E3 ]   ; Get special object's Id 
       cmpa  #0xF4 
       bne   P040D 
       lda   $C8E0       ; Get obj's intensity adj value 
       cmpa  #0x3C        ; Don't interact, if player is 
       bge   P040D        ; too far away from Dark Tower. 

       ; Attempt to solve riddle if player moving forward 
       lda   $C81C       ; Get joystick u/d position 
       ble   P040D 
       lda   $C81B       ; Get joystick l/r position 
       bne   P040D 
       pshs  x,y,u 
       jsr   TryToSolveRiddleOfKeys 
       jsr   TryToStartFog  ; Force player to random spot 
       puls  x,y,u 
P040D: clr   $CBA0       ; Don't flip image 
       lda   #0x7F 
       suba  3,u 
       tfr   a,b 
       adda  #0x30 
       bvc   P041C 
       lda   #0x7F 
P041C: suba  $C9A1 
       cmpa  #0x20 
       ble   P0437 
       aslb 
       addb  #0x68 
       bhs   P042A 
       ldb   #0xFF 
P042A: std   $C8AB      ; Set intensity & scale values 
       ldd   #DarkTowerRightHalf ; Set vector list 1 
       ldx   #DarkTowerLeftHalf  ; Set vector list 2 
       leay  1,u         ; Set addr of drawing position 
       jsr   Draw2VectorLists 
P0437: puls  dp 
       jmp   P01DE 

; ProcessKeysInForest()
;
; This function does nothing, if the player already has
; all of the keys.  Otherwise, it determines if the player
; has moved close enough to pick up the key  movement to
; the left, right or backwards will not result in the
; player picking up the key.
 
ProcessKeysInForest:
       pshs  dp 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       jsr   CheckIfAllKeysAwarded 
       blo   P044C        ; Jump if all keys found 
       jsr   CheckIfObjectConsumed 
       beq   P0451        ; Branch if obj not yet consumed 
P044C: puls  dp 
       jmp   P01DE 
P0451: lda   [ $C8E3 ]   ; Get special objects Id 
       cmpa  #0xF0 
       bne   DrawKeyInForest 
       lda   $C8E8       ; Has key already been consumed? 
       bne   P044C        ; Yep, so skip it 
       lda   $C8E0       ; Get obj's intensity adj value 
       cmpa  #0x3C        ; Don't pick it up, if player is 
       bge   DrawKeyInForest  ; too far away. 
       lda   $C81C       ; Get joystick u/d position 
       ble   DrawKeyInForest  ; Player moved backwards 
       lda   $C81B       ; Get joystick l/r position 
       bne   DrawKeyInForest  ; Player moved left or right 

; Upward (forward) movement 
; 
; Attempt to reward the player with one of the keys 
; make sure it's one he doesn't already have.
 
       jsr   AwardGoldKey 
       bne   P047F 
       jsr   AwardBronzeKey 
       bne   P047F 
       jsr   AwardSilverKey 
       bne   P047F 
       jsr   AwardBrassKey 
       beq   P044C 
P047F: lda   [ $C8E5 ]      ; Get 'consumed' byte 
       ora   $C8E7          ; Flag object as 'consumed' 
       sta   [ $C8E5 ]      ; Save updated 'consumed' byte 
       sta   $C8E8          ; Save 'been consumed' flag 
       pshs  u 
       ldu   #AwardSound 
       jsr   SPLAY
       puls  u 
       bra   P044C 

; DrawKeyInForest()
;
; This function attempts to draw a visible key in the
; forest.  It will determine if the key is visible (by
; calculating the scale and intensity values), and if
; it is not, will not draw the key.
 
DrawKeyInForest:
       clr   $CBA0       ; Don't flip image 
       lda   #0x7F 
       suba  3,u          ; Calculate intensity value 
       tfr   a,b 
       adda  #0x30 
       bvc   P04A6 
       lda   #0x7F 
P04A6: suba  $C9A1      ; Include fog factor 
       cmpa  #0x20       ; Skip if intensity <= 0x20 
       ble   P044C 
       lsrb              ; Calculate scale value 
       lsrb 
       addb  #0x08 
       cmpb  #0x10 
       ble   P044C       ; Skip if scale <= 0x10 
       puls  dp 
       ldx   #Key        ; Get vector list 
       leay  1,u         ; Get ptr to drawing position 
       jsr   DT_MoveThenDraw 
       jmp   P01DE 

; ProcessBagsOfGoldInForest()
;
; Checks to see if the bag of gold has already been picked
; up by the player, and if not, checks to see if the player
; is close enough to pick it up, and is moving towards the
; bag.  If all criteria is met, then the bag is consumed.
 
ProcessBagsOfGoldInForest:
       pshs  dp 
       lda   #0xC8 
	direct $C8
       tfr   a,dp 
       jsr   CheckIfObjectConsumed 
       beq   P04D2        ; Keep going, if not consumed yet 
P04CD: puls  dp           ; Object already consumed; exit 
       jmp   P01DE 
P04D2: lda   [ $C8E3 ]   ; Get special object's Id 
       cmpa  #0xF2 
       bne   DrawBagOfGold 
       lda   $C8E8       ; Has gold already been consumed? 
       bne   P04CD        ; Yep, so skip it 
       lda   $C8E0       ; Get obj's intensity adj value 
       cmpa  #0x3C        ; Don't pick up, if player is 
       bge   DrawBagOfGold  ; too far away. 
       lda   $C81C       ; Get joystick u/d position 
       ble   DrawBagOfGold 
       lda   $C81B       ; Get joystick l/r position 
       bne   DrawBagOfGold 

; Upward (forward) movement 
       pshs  u 
       ldd   $C8DD       ; Award 1 bag of gold, unless 
       addd  #0x0001      ; the player already has the 
       blo   P04FF        ; maximum number of bags. 
       std   $C8DD       ; Save new gold count 
       lda   #0x01        ; # of bags awarded 
       ldx   #0xCB4B      ; Ptr to 'Bags of gold' buffer 
       jsr   UpdateAwardsStringBuffer 
P04FF: ldx   #0xCB3A        ; Add 100 to player's score 
       ldd   #0x0100 
       jsr   SCRADD
       ldu   #AwardSound 
       jsr   SPLAY        ; Make a sound 
       puls  u 
       lda   [ $C8E5 ]   ; Get 'consumed' byte 
       ora   $C8E7       ; Flag object as 'consumed' 
       sta   [ $C8E5 ]   ; Save updated 'consumed' byte 
       sta   $C8E8       ; Save 'been consumed' flag 
       bra   P04CD 

; DrawBagOfGold()
;
; Entry: u => ptr to visible object
;
; This function determines if the bag of gold is really
; visible (based on its calculated scale and intensity
; values).  If it is visible, then it is drawn.
;
 
DrawBagOfGold:
       clr   $CBA0       ; Don't flip image 
       lda   #0x7F        ; Calculate intensity value 
       suba  3,u 
       tfr   a,b 
       adda  #0x30 
       bvc   P052D 
       lda   #0x7F 
P052D: suba  $C9A1       ; Include fog factor 
       cmpa  #0x20 
       ble   P04CD        ; Skip if intensity <= 0x20 
       lsrb               ; Calculate scale value 
       lsrb 
       addb  #0x08 
       cmpb  #0x10 
       ble   P04CD        ; Skip if scale <= 0x10 
       puls  dp 
       ldx   #BagOfGold   ; Get vector list 
       leay  1,u          ; Get ptr to drawing position 
       jsr   DT_MoveThenDraw 
       jmp   P01DE 

; ProcessMovementAndDrawPlayer()
;
; This function checks to see if the player is trying to
; move, and if so, whether or not the forest information
; must be regenerated.  It then draws the player, either
; walking, or standing still, depending upon what the
; player is currently doing.
 
ProcessMovementAndDrawPlayer:
       lda   $C8EB 
       lbeq  P0655        ; Skip, if player is dead 
       lda   #0x70        ; Calculate player's intensity 
       suba  $C9A1       ; Include fog factor 
       suba  $C8F0       ; Include plague factor 
       cmpa  #0x20        ; Skip if calculated intensity 
       lble  P0655        ; is <= 0x20. 
       ldb   #0x30 
       std   $C8AB 
       lda   $C8BF       ; Jump, if player's in a chest 
       lbne  PlayerStandingStill 
       lda   $C81B       ; Get joystick l/r position 
       ora   $C81C       ; Get joystick u/d position 
       lbeq  PlayerStandingStill  ; Skip if in neutral 
       lda   $C8A8       ; 'Slow down' flag disabled? 
       bne   CheckForMovement  ; Nope; don't update l/r pos 
       lda   $C81B       ; Get joystick l/r position 
       beq   CheckForMovement  ; Skip if not left or right 
       bmi   TurnLeft     ; Is joystick 'left'? 

; TurnRight()
;
; Decrement the players angle of travel.
 
TurnRight:
       dec   $C8B2       ; Nope; joystick is 'right' 
       bra   UpdateDirection 

; TurnLeft()
;
; Increment the players angle of travel.
 
TurnLeft:
       inc   $C8B2       ; Joystick is 'left' 

; UpdateDirection()
;
; Update all values associated with the players direction
; of travel.
 
UpdateDirection:
       jsr   PlayerChangedDirection 

; CheckForMovement()
;
; Check to see if the player is asking to move forward
; or backward.  If so, then update the step count, and
; the player's position within the forest.  If the player's
; forest position has changed, then update the forest
; information.
 
CheckForMovement:
       lda   $C8A9       ; Is 'slow down' flag disabled? 
       bne   NoUpdate    ; Nope, so don't update 
       lda   $C81C       ; Get joystick u/d position 
       beq   UpdateForestInfo  ; Skip if not up or down 
       bmi   MoveDown    ; Jump if joystick is 'down' 

; Joystick is in 'up' position  go forward 
MoveUp:
       ldd   $C8BA       ; Add 'rise' to 'y' position 
       addd  $C8B4       ; Add in player's 16-bit 'y' pos 
       std   $C88F       ; Save in temporary storage 
       bita  #0xC0        ; Skip if player is out of bounds 
       bne   NoUpdate     ; I.e. don't update forest info 
       ldd   $C8BC       ; Add 'run' to 'x' position 
       addd  $C8B6       ; Add in player's 16-bit 'x' pos 
       std   $C891       ; Save in temporary storage 
       bita  #0xC0        ; Skip if player is out of bounds 
       bne   NoUpdate     ; I.e. don't update forest info 
       ldx   #0xCB45      ; Increment the number of steps 
       lda   $CB4A       ; taken by player. 
       jsr   IncrementSignedString 
       sta   $CB4A       ; Save 'step count = 0' indicator 
       bra   CheckIfUpdateNecessary 

; Joystick is in 'down' position  back up 
MoveDown:
       ldd   $C8BA       ; Subtract 'rise' from 'y' pos
       coma               ; Negate the 'rise' value, to 
       comb               ; move the player down. 
       addd  #0x0001      ; Make into 2's compliment 
       addd  $C8B4       ; Add in player's 16-bit 'y' pos 
       std   $C88F       ; Save in temporary storage 
       bita  #0xC0        ; Skip if player is out of bounds 
       bne   NoUpdate     ; I.e. don't update forest info 
       ldd   $C8BC       ; Subtract 'run' from 'x' pos 
       coma               ; Negate the 'run' value, to 
       comb               ; move the player down. 
       addd  #0x0001      ; Make into 2's compliment 
       addd  $C8B6       ; Add in player's 16-bit 'x' pos 
       std   $C891       ; Save in temporary storage 
       bita  #0xC0        ; Skip if player is out of bounds 
       bne   NoUpdate     ; I.e. don't update forest info 
       ldx   #0xCB45      ; Decrement the number of steps 
       lda   $CB4A       ; taken by player. 
       jsr   DecrementSignedString 
       sta   $CB4A       ; Save 'step count = 0' indicator 

; CheckIfUpdateNecessary()
;
; If the player's position within the forest has changed
; significantly from the position last used to generate
; the forest data, then regenerate the forest data, based
; on the player's new position.
 
CheckIfUpdateNecessary:
       ldd   $C88F       ; Load updated 'y' position 
       std   $C8B4       ; Update player's 'y' position 
       ldd   $C891       ; Load updated 'x' position 
       std   $C8B6       ; Update player's 'x' position 
       cmpa  $C8B9       ; If the top byte of the player's 
       bne   UpdateForestInfo  ; x and y positions have not 
       ldb   $C8B4       ; changed, then don't bother 
       cmpb  $C8B8       ; updating the forest info, since 
       beq   NoUpdate     ; the view will not have changed. 

; Player's position has changed, so update viewing info 
UpdateForestInfo:
       ldb   $C8B4       ; Save off the new x and y values 
       stb   $C8B8       ; since they are the ones now 
       lda   $C8B6       ; being used to generate the 
       sta   $C8B9       ; forest view information. 
       jsr   FillInVisibleForestInfo 
       jsr   CheckForPlagueOrFog 
       bra   ProcessPlayerWalking 

; Existing forest data still valid  no need to update 
NoUpdate:
       jsr   P06AE 

; ProcessPlayerWalking()
;
; If the player is not already walking, then it generates
; a random animation index, to use to start the player
; walking.
 
ProcessPlayerWalking:
       lda   $C8BE       ; Is player already walking? 
       bne   DrawPlayerWalking  ; Yes; so draw him walking 
       jsr   RANDOM       ; No, so decide what animation 
       anda  #0x03        ; index to start with. 
       bne   DrawPlayerWalking 
       ora   #0x01        ; Player starting to walk; set 
       sta   $C8F2       ; initial player animation index. 

; DrawPlayerWalking()
;
; This function draws the player actively walking.
 
DrawPlayerWalking:
       lda   $C8A9      ; Is 'slow down' flag disabled? 
       bne   P0616       ; Nope, so don't update 
       inc   $C8F2      ; Increment player animation index 
       lda   #0x04 
       sta   $CB6C 
P0616: lda   #0x01 
       sta   $C8BE      ; Flag that player is walking 
       bra   DrawPlayer 

; PlayerStandingStill()
;
; This forces the player to a standstill.
 
PlayerStandingStill:
       lda   #0x00       
       sta   $C8BE      ; Flag player as standing still 
       clr   $C8F2      ; Clear animation index 

; DrawPlayer()
;
; Draw the player, either walking, or standing still.
; If the player is walking, then it uses the player's
; animation index to draw the appropriate set of vectors, 
; to give the effect that the player is first moving the 
; left leg, then the right, etc.
 
DrawPlayer:
       lda   $C8EB      ; Is player dead? 
       beq   P0655       ; Skip, if player is dead 
P0626: lda   $C8F2      ; Load player animation index 
       ldx   #PlayerWalkingImageControlTable 
       ldb   a,x 
       stb   $CBA0      ; Control flipping of image 
       asla 
       ldx   #PlayerWalking_LeftSide_Table 
       ldx   a,x 
       stx   $C8AF     ; Set alternate vector list 2 
       ldx   #PlayerWalking_RightSide_Table 
       ldx   a,x 
       stx   $C8AD     ; Set alternate vector list 1 
       bne   P0647 
       lda   #0x01      ; When the last vector list is 
       sta   $C8F2     ; reached, reset the player's 
       bra   P0626      ; animation index back to 1. 
P0647: ldb   $C8F1     ; Retrieve player drawing pattern 
       stb   $C829     ; Set line drawing pattern 
       ldd   #0x0000    ; Force drawing of alt vector lists 
       ldy   #0xC8EC    ; Set addr of drawing position 
       jsr   Draw2VectorLists_16bit 
P0655: rts 

; FillInVisibleForestInfo()
;
; This function is responsible for filling in both the
; array of forest data and the array of visible objects.
 
FillInVisibleForestInfo:
       ldu   #0xC9A6 
       ldb   #0x12 
       stb   $C88F     ; Set loop counter 1 
       stb   $C890     ; Set loop counter 2 
       ldd   #0x0000 
P0662: std   0,u        ; Clear out all forest entries 
       leau  9,u 
       dec   $C890 
       bne   P0662      ; Process next array entry 

       ldu   #0xC9A6    ; Prepare to fill forest array 
       clr   $C8D2     ; Initially, no object are visible 
       ldy   #DirectionalForestData 
       lda   $C8B2     ; Get angle of travel 
       lsra             ; Convert to compass direction 
       lsra 
       anda  #0x1E      ; Get forest information, based on 
       ldy   a,y        ; player's direction of travel. 
       lda   $C8B4     ; Get player's y position 
       suba  #0x06      ; Decrement it by 6 
       sta   $C883     ; Save for later use 
       lda   $C8B6     ; Get player's x position 
       suba  #0x06      ; Decrement it by 6 
       sta   $C884     ; Save for later use 
P0688: jsr   GenerateForestData 
       blo   P06AE     ; If 'carry' set, then all done 
       bvs   P0688     ; Branch if 'overflow' bit set 
       stb   6,u       ; Save 'image flip' control bit 
       ldx   #ObjectVectorTable 
       asla            ; Use return info to index into 
       ldd   a,x       ; object vector table. 
       std   0,u       ; Save object id 
       clrb 
       lda   $C885    ; Save player's y position? 
       std   2,u 
       lda   $C886    ; Save player's x position? 
       std   4,u 
       clr   7,u       ; Clear object state machine index 
       clr   8,u       ; Clear chest animation index 
       inc   $C8D2    ; Increment # of visible trees 
       leau  9,u       ; Point to next tree array entry 
       dec   $C88F    ; Decrement loop counter 
       bne   P0688     ; Process next entry 

P06AE: ldu   #0xCA48   ; Get ptr to tree position data 
       ldb   #0x20     ; Set loop counter 
P06B3: clr   0,u       ; Flag entry as 'inactive' 
       leau  6,u       ; Point to next array entry 
       decb            ; Decrement loop counter 
       bne   P06B3     ; Process next array entry 

       ldd   #0x0000 
       std   $C8E1    ; Clear 'special object' pointer 
       sta   $C8E9 
       coma 
       sta   $C8E0    ; Set initial intensity adj value 
       lda   #0xFC 
       sta   $C8C9 
       lda   #0xE0 
       sta   $C8CB 
       ldd   $C8C4 
       std   $C837    ; Init rotation routine cosine value 
       ldd   $C8C6 
       std   $C839     ; Init rotation routine sin value 
       ldx   #0xC9A6    ; Get ptr to Visible Tree array 
       lda   $C8D2     ; Were any trees visible? If not, 
       beq   P074A      ; then branch elsewhere. 
       sta   $C88F     ; Set loop counter 
P06DD: ldd   0,x        ; Jump elsewhere if this entry 
       beq   P0744      ; does not point to a tree. 
       ldd   $C8B6     ; Get player's 16-bit x position 
       subd  4,x 
       asra 
       rorb 
       asra 
       rorb 
       asra 
       rorb 
       stb   $C8C8 
       ldd   $C8B4     ; Get player's 16-bit y position 
       subd  2,x 
       asra 
       rorb 
       asra 
       rorb 
       asra 
       rorb 
       stb   $C8CA 
       jsr   TransformPoint 
       bvs   P0744 
       ldb   $C8CE        ; Generate an index, in the 
       addb  #0x80         ; range of 0-31. 
       lsrb 
       lsrb 
       lsrb 
       ldu   #0xCA48       ; Generate pointer to the 
       lda   #0x06         ; indicated 'visible object' 
       mul                 ; array entry. 
       leau  d,u 
       lda   0,u 
       beq   P0717         ; Branch if no visible object 
       lda   $C8CC 
       cmpa  3,u 
       bhi   P0744 
P0717: ldd   0,x           ; Is this a tree, or some other 
       tsta                ; special object? 
       beq   P071E         ; It's a special object 
       ldb   #0x01         ; It's a tree 
P071E: stb   0,u           ; Set flag in visible obj entry 
       stx   4,u           ; Save pointer to forest entry 
       ldb   $C8CC 
       stb   3,u 
       lda   $C8CD 
       sta   1,u 
       lda   $C8CE 
       sta   2,u 
       cmpa  #0xE0 
       ble   P0744 
       cmpa  #0x30 
       bge   P0744 
       cmpb  #0x80 
       bhi   P0744 
       cmpb  $C8E0     ; Skip this object, if its farther 
       bhi   P0744      ; away than another special object. 
       stb   $C8E0     ; Save obj's intensity adj value 
       stx   $C8E1     ; Save ptr to associated forest obj 
       stu   $C8E3     ; Save ptr to visible object 
P0744: leax  9,x        ; Point to next array entry 
       dec   $C88F     ; Decrement loop counter 
       bne   P06DD      ; Process next entry 
P074A: rts 

; CheckIfFogActive()
;
; Controls the processing of the fog.  If C9A0 = 0,
; then a fog is not in effect.  If C9A0 = 1, then the
; fog is starting, and will get thicker over time.  If
; C9A0 = 0x80, then the fog is receding, and will get
; thinner over time.
 
	direct $D0
CheckIfFogActive:
       lda   $C9A0     ; Check if fog is active, 
       lbeq  P07EC      ; increasing, or decreasing. 
       bmi   DecreaseFog  
       inc   $C9A1     ; Increment fog duration counter 
       lda   $C9A1 
       cmpa  #0x60      ; Is it done getting thick? 
       blo   DrawFog    ; Nope 
       lda   #0x80      ; Yep; time to decrease fog 
       sta   $C9A0     ; Set flag = 'decrease fog' 
       lda   $C8C1 
       bne   P0775 
       lda   $C8DB     ; Does player have a scout? 
       beq   P0775      ; Nope; do random placement 
       dec   $C8C2     ; Decrement # of scout uses left 
       bpl   DecreaseFog  ; Has scout been used up? 
       clr   $C8DB     ; Yep, so remove from inventory 
P0775: pshs  dp         ; and randomly reposition the 
       lda   #0xC8      ; player elsewhere in the forest. 
	direct $C8
       tfr   a,dp 
       jsr   PlacePlayerRandomlyInForest 
	direct $D0
       puls  dp 
DecreaseFog:
       dec   $C9A1     ; See if fog duration has passed 
       ble   FogDone 
DrawFog:
       clr   $C887     ; Clear loop counter 
       lda   $C9A1     ; Calculate the intensity to use 
       adda  #0x20      ; Do some adjustments 
       bvc   P0791      ; Check for overflow 
       lda   #0x7F      ; Use the maximum intensity value 
P0791: jsr   INTENS
       jsr   RANDOM
       anda  #0x1F      ; Calculate a pseudo-random 
       adda  #0x90      ; position on the screen; this is 
       ldb   #0x00      ; where the fog line will be drawn. 
       jsr   POSITD
       ldd   #0x0158 
       std   $C884     ; Endpoint for 'Fog' lines 
       jsr   RANDOM
       anda  #0x7F      ; Calculate a random scale factor, 
       ora   #0x60      ; in the range 0x60 - 0x7F. 
       sta   $D004     ; Set the drawing scale factor 
RedrawFogLine:
       inc   $C887     ; Increment loop counter 
       lda   $C887     ; Stop drawing, when C887 > C9A1 
       cmpa  $C9A1 
       bhi   P07EC 
       ldd   $C884     ; Retrieve 'Fog' starting point 
       negb             ; Draw from (y,x) to (y,-x) 
       stb   $C885     ; Modify last x coordinate
       sta   $D001     ; Set 'y' position 
       clr   $D000 
       tst   $FF00      ; Just a 'nop' 
       inc   $D000 
       stb   $D001     ; Set 'x' position 
       ldd   #0xFF00 
       sta   $D00A     ; Set drawing pattern 
       stb   $D005 
       ldd   #0x0040 
P07D6: bitb  $D00D     ; Wait for drawing to finish 
       beq   P07D6 
       nop 
       sta   $D00A     ; Clear drawing pattern 
       jsr   RANDOM
       ora   #0xC0 
       sta   $D004     ; Set random drawing scale factor 
       bra   RedrawFogLine 

FogDone:
       clr   $C9A0     ; Flag that 'Fog' sequence is over 
       clr   $C9A1 
P07EC: jmp   ZERGND

; CheckForPlagueOrFog()
;
; This function appears to see if the current forest
; location has a plague or fog associated with it, and
; if so, attempts to activate it.
 
	direct $C8
CheckForPlagueOrFog:
       ldy   #0x0824 
       lda   $C8B4     ; Get player's y position 
       suba  #0x06      ; Decrement it by 6 
       sta   $C883     ; Save for later use 
       lda   $C8B6     ; Get player's x position 
       suba  #0x06      ; Decrement it by 6 
       sta   $C884     ; Save for later use 
P07FF: jsr   GenerateForestData 
       blo   P0823      ; If 'carry' set, then all done 
       bvs   P0814      ; Branch if 'overflow' bit set 
       tfr   a,b        ; Save copy of 'object type' info 
       andb  #0x0E 
       eorb  #0x0E 
       bne   P07FF 
       anda  #0x01 
       beq   P0820 
       bra   P081C 
P0814: jsr   TryToStartFog 
       lda   #0x01 
       sta   $C8C1 
       rts 
P081C: jsr   TryToStartFog 
       rts 
P0820: jsr   TryToStartPlague 
P0823: rts 

S0824: db    0x05 
       db    0x05 
       db    0x05 
       db    0x06 
       db    0x05 
       db    0x07 
       db    0x06 
       db    0x05 
       db    0x06 
       db    0x06 
       db    0x06 
       db    0x07 
       db    0x07 
       db    0x05 
       db    0x07 
       db    0x06 
       db    0x07 
       db    0x07 
       db    0x00 
       db    0x00 

; CheckIfPlagueIsActive()
;
; Controls the processing of the plague.  If C9A2 = 0,
; then the plague is not in effect.  If C9A2 = 1, then the
; plague is starting, and will get thicker over time.  If
; C9A2 = 0x80, then the plague is receding, and will get
; thinner over time.
 
	direct $D0
CheckIfPlagueIsActive:
       lda   $C9A2        ; Is 'plague in progress'? 
       lbeq  P08EA         ; Skip if plague not active 
       bmi   DrawPlagueLines  ; Jump if already in progress 
       inc   $C9A3        ; Increment duration counter 
       lda   $C9A3 
       tfr   a,b 
       lsrb 
       stb   $C8F0 
       cmpa  #0x60         ; Is plague done increasing? 
       blo   P0870         ; Nope 
       lda   #0x80         ; Yep; so start it decreasing 
       sta   $C9A2         
       lda   $C8DC        ; Check to see if the player 
       beq   P0863         ; has a healer; skip if not 
       dec   $C8C3        ; Decrement Healer uses left 
       bpl   DrawPlagueLines  ; Has Healer been used up? 
       clr   $C8DC        ; Yep; clear from inventory 
P0863: clr   $C8EB        ; Flag that player is dead 
       lda   #0x90 
       sta   $C89C        ; Reset startup delay timer 
DrawPlagueLines:
       dec   $C9A3        ; Decrement duration counter 
       ble   PlagueDone 
P0870: clr   $C883        ; Clear loop counter 
       lda   $C9A3        ; Calculate intensity value 
       adda  #0x20         ; Make some adjustments 
       bvc   P087C         ; Check for overflow 
       lda   #0x7F         ; If overflow, use max value 
P087C: jsr   INTENS
       jsr   RANDOM        ; Calculate a random line 
       sta   $C8F1        ; pattern for drawing player. 
       anda  #0x0F         ; Calculate random position, in 
       adda  #0x90         ; range (0x81,0) to (0x90,0) 
       ldb   #0x00 
       jsr   POSITD
       ldd   #0x0158 
       std   $C884        ; Save initial drawing position 
       jsr   RANDOM
       anda  #0x1C 
       sta   $D004        ; Generate random scale factor 
RedrawPlagueLine:
       inc   $C883        ; Increment loop counter 
       lda   $C883 
       cmpa  $C9A3        ; Are we done yet? 
       bhi   P08EA         ; Jump, if done 
       ldd   $C884        ; Load drawing position 
       negb                ; Set endpoint = (y, -x) 
       bmi   P08AD         ; Adjust, if necessary 
       decb 
P08AD: stb   $C885        ; Modify saved x coordinate 
       sta   $D001        ; Set y drawing position 
       clr   $D000 
       tst   $FF00          ; Just a nop 
       inc   $D000 
       stb   $D001        ; Set x drawing position
       lda   $C829        ; Get current drawing pattern 
       ldb   #0x40         ; Set up interrupt check flag 
       sta   $D00A        ; Set drawing pattern 
       clr   $D005 
P08C4: lda   $C829        ; Get current drawing pattern 
       sta   $D00A        ; Set drawing pattern 
       nop                 ; Until the drawing timer 
       bitb  $D00D        ; elapses, keep resetting the
       beq   P08C4         ; line drawing pattern. 
       clr   $D00A        ; Clear line drawing pattern 
       jsr   RANDOM
       sta   $C829        ; Get random drawing pattern 
       jsr   RANDOM
       anda  #0x3F         ; Calculate random scale factor 
       adda  $C9A3 
       sta   $D004        ; Set scale factor 
       bra   RedrawPlagueLine 
PlagueDone:
       clr   $C9A2        ; Clear 'In Progress' flag 
       lda   #0xFF 
       sta   $C8F1        ; Set player drawing pattern 
P08EA: jmp   ZERGND

; PlayerEnteringChest()
;
; This function is activated when the user enters a
; brigand chest.  It is responsible for saving off the
; current state of any visible objects in the forest,
; and initializing the brigand data.  It then transitions
; the player into the chest, and processes the fighting
; between the player and the brigand, until either the
; player defeats the random number of brigands, or the
; player is killed.  If the player defeats the brigands,
; then he is awarded a random prize, and then placed back
; into the forest.  If the player dies, then he is placed
; back into the forest.
 
	direct $C8
PlayerEnteringChest:
       jsr   PreserveVisibleObjectData 
       jsr   ClearAllGameStorageArrays 
       ldx   #BrigandDefaults 
       ldu   #0xC9E0       ; Get ptr to brigand array 
       ldb   #0x18         ; Set byte/loop counter 
P08FB: lda   ,x+           ; Init the brigand array, using 
       sta   ,u+           ; the default values stored in 
       decb                ; ROM. 
P0900: bne   P08FB 
       pshs  dp 
       jsr   SetPlayersPositionInChest 
       jsr   RANDOM
       anda  #0x7F 
       ora   #0x80 
       sta   $C89F       ; Set up action delay timer 
       lda   #0x80 
       sta   $CB89       ; Flag start of dot sequence 
       lda   #0x3F 
       sta   $CB8A 
       lda   #0x1F 
       sta   $CB8B 
       lda   #0x01 
       sta   $C8BF       ; Flag that player's in a chest 
       ldu   #EnteringChestSound 
       jsr   SPLAY
	direct $D0
P0929: jsr   CheckForInventoryRequest 
       lda   $CB8B 
       ble   P0936 
       dec   $CB8B 
       bra   P093F 
P0936: ldd   #0xCD00      ; Force a specific (y,x) location 
       jsr   DrawDotsIfActive 
       sta   $C8F0 
P093F: jsr   CheckForFiringOrMovement 
       jsr   ProcessBrigand 
       lda   $CB89       ; Jump if the dot sequence 
       bne   P0929        ; has not completed. 
       clr   $C8BF 
P094D: jsr   CheckForInventoryRequest 
       jsr   CheckForFiringOrMovement 
       jsr   ProcessBrigand 
       jsr   UpdateFlamoids 
       jsr   ProcessExplodingObjects 
       jsr   CheckFlamoidsForHits 
       lda   $C9A3 
       bne   P094D 
       lda   $C8EB 
       beq   P09DB        ; Skip, if player is dead 
       lda   $C8E9 
       bpl   P094D 
       lda   $C9A0       ; Were any brigands processed? 
       bne   P094D        ; Keep looping, if so 
       lda   $C9A1 
       beq   P094D 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       clr   $C89F       ; Disable C8A0 invocation 
       lda   #0x01 
       sta   $C8BF       ; Flag that player's in a chest 
	direct $D0
       ldu   #RandomAwardsTable2 
       jsr   InvokeRandomFunctionFromTable 
       jsr   SetLabelOfFoundObject 
P098B: jsr   CheckForInventoryRequest 
       jsr   DrawEnlargingString 
       jsr   CheckForFiringOrMovement 
       jsr   ProcessBrigand 
       jsr   UpdateFlamoids 
       jsr   ProcessExplodingObjects 
       lda   $C8F7      ; Keep looping until the award 
       cmpa  #0x60       ; string has enlarged enough. 
       blt   P098B 
       lda   #0x01 
       sta   $CB89      ; Flag start of dot sequence 
       clr   $CB8A 
       lda   #0x0F 
       sta   $CB8B 
P09B1: jsr   CheckForInventoryRequest 
       lda   $CB8B 
       ble   P09BE 
       dec   $CB8B 
       bra   P09C7 
P09BE: ldd   $C8D0      ; Load some (y,x) value 
       jsr   DrawDotsIfActive 
       sta   $C8F0 
P09C7: jsr   DrawEnlargingString 
       jsr   CheckForFiringOrMovement 
       jsr   ProcessBrigand 
       jsr   UpdateFlamoids 
       jsr   ProcessExplodingObjects 
       lda   $CB89      ; Jump if the dot sequence 
       bne   P09B1       ; has not completed. 
P09DB: lda   #0xC8 
       tfr   a,dp 
	direct $C8
       clr   $C89F       ; Disable C8A0 invocation 
       clr   $C8A2       ; Disable C8A3 invocation 
       jsr   SetPlayersPositionInForest 
       lda   $C8EB 
       bne   P09F0        ; Skip, if player is alive 
       ldu   #PlayerDeadSound 
       jsr   SPLAY
P09F0: lda   #0x7F 
       sta   $C8F0 
       jsr   ClearAllGameStorageArrays 
       jsr   FillInVisibleForestInfo 
       jsr   RestoreVisibleObjectData 
       puls  dp,pc 

; ProcessBrigand()
;
; Exit: C9A0  = 0, if no brigands to process, else
;            != 0, if at least 1 brigand was processed.
;
; This function is responsible for processing all of the
; active brigands.  It will update the animation for each
; brigand, and decide if the animation is complete, so the
; corresponding brigand can be deactivated.  Otherwise, if
; the brigand has not already thrown a flamoid, it decides
; if it is time for it to do so.  It will randomly decide
; whether to throw it directly at the player, or in a
; random direction.
 
	direct $D0
ProcessBrigand:
       ldu   #0xC9E0     ; Get ptr to brigand array 
       lda   #0x06 
       sta   $C88F      ; Set loop counter 
       clr   $C9A0      ; Clear return value 
P0A0A: ldb   0,u         ; Only process visible brigands 
       lbpl  P0AAE 
       lda   $C9A0      ; Set return value to show that 
       ora   #0x01       ; at least 1 brigand was processed 
       sta   $C9A0 
       ldy   2,u         ; Get ptr to brigand position info 
       pshs  dp,y,u 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       lda   $C8A9      ; Is 'slow down' flag disabled? 
       bne   P0A60       ; Nope, so don't update 
       inc   1,u         ; Increment animation index 
       bitb  #0x40       ; Has this brigand already thrown 
       bne   P0A60       ; a flamoid?  Branch if yes 
       ldx   #FlamoidControlTable  ; Determine if the 
       lda   1,u         ; animation has reached the point 
       lda   a,x         ; where the flamoid can be thrown. 
       beq   P0A60       ; Branch if not ready to throw 
       orb   #0x40 
       stb   0,u         ; Flag that flamoid's been thrown 
       jsr   RANDOM
       bita  #0x70       ; Use a random # to determine 
       bne   P0A49       ; whether to throw directly at 
       anda  #0x87       ; player, or randomly. 
       bpl   P0A45 
       ora   #0xF9 
P0A45: adda  #0x20 
       bra   P0A56 
P0A49: lda   4,y         ; Load brigand's y position 
       suba  $C8EC      ; Subtract off player's y position 
       ldb   6,y         ; Load brigand's x position 
       subb  $C8EE      ; Subtract off player's x position 
       jsr   CMPASS
       adda  #0x10       ; Calculate angle to player 
P0A56: ldx   6,y         ; Get flamoids initial x pos 
       ldb   8,y 
       ldy   4,y         ; Get flamoids initial y pos 
       jsr   TryToFireNewFlamoid 
	direct $D0
P0A60: puls  dp,y,u 
       lda   1,u         ; Get the animation index 
       asla 
       sta   $C890      ; Save the animation index 
       lda   13,y 
       sta   $CBA0      ; Control flipping of image 
       ldx   #BrigandArmAndBodyTable 
       lda   $C890 
       ldx   a,x         ; Skip drawing, if vector table 
       cmpx  #0xFFFF     ; entry is 0xFFFF. 
       beq   P0AAE 
       cmpx  #0x0000     ; See if animation has completed 
       beq   P0AA8       ; Branch if complete 
       lda   #0x60       ; Set drawing intensity 
       ldb   14,y        ; Get scale factor 
       std   $C883      ; Save them away 
       leay  0,y         ; Get location to move to 
       sty   $C885      ; Save them away 
       jsr   DT_16bitMoveThenDraw 
       ldx   #BrigandHeadTable 
       lda   $C890      ; Use animation index to index 
       ldx   a,x         ; into the vector list table. 
       cmpx  #0xFFFF     ; Skip drawing, if vector table 
       beq   P0AAE       ; entry is 0xFFFF. 
       ldd   $C883      ; Retrieve intensity & scale info 
       ldy   $C885      ; Retrieve ptr to (y,x) position 
       jsr   DT_16bitMoveThenDraw 
       bra   P0AAE 
P0AA8: lda   #0x01       ; Flag that the brigand animation 
       sta   0,u         ; sequence has completed. 
       clr   1,u         ; Reset animation index 
P0AAE: leau  4,u         ; Process next array entry, if 
       dec   $C88F      ; any are left. 
       lbne  P0A0A 
       rts 

; CheckForFiringOrMovement()
;
; This function first checks to see if the player is
; attempting to fire a flamoid, and if so, then it
; fires one in the indicated direction.  If not, then
; it checks to see if the player is trying to move left
; or right.  This function is called when the player is
; in a treasure chest.
 
CheckForFiringOrMovement:
       pshs  dp 
       lda   $C8EB 
       lbeq  P0BB5      ; Skip, if player is dead 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       clr   $C88F 
       clr   $CBA0     ; Don't flip image 
       lda   $C8C0 
       bne   P0AF1 
       lda   $C8BF 
       lbne  P0B77 
       lda   $C814     ; Get console 1, btn 3 state 
       beq   P0ADC 
       lda   #0x00      ; Fire straight (angle = 0 deg) 
       bra   P0AEA 
P0ADC: lda   $C815     ; Get console 1, btn 4 state 
       beq   P0AE4 
       lda   #0x3D      ; Fire right (angle = 15 deg right) 
       bra   P0AEA 
P0AE4: lda   $C813     ; Get console 1, btn 2 state 
       beq   CheckForLRMovement 
       lda   #0x03      ; Fire left (angle = 15 deg left) 
P0AEA: inc   $C8C0 
       clr   $C8F2     ; Set image index = 0 
       sta   $C9A2      ; Save angle of fire 
P0AF1: lda   $C8AA 
       bne   P0B1A 
       ldx   #PlayerFireSynchronization 
       inc   $C8F2      ; Increment animation index 
       lda   $C8F2      ; See if the animation is now 
       lda   a,x         ; synched for flamoid to appear. 
       beq   P0B1A       ; Jump if not yet synched 
       lda   $C8EC      ; Get player's y position 
       clrb 
       tfr   d,y         ; Flamoids initial y position 
       lda   $C8EE      ; Get player's x position 
       adda  #0x02 
       clrb 
       tfr   d,x         ; Flamoids initial x position 
       ldb   #0xF8 
       lda   $C9A2      ; Angle to fire flamoid 
       jsr   TryToFireNewFlamoid 
       lda   0,u 
       ora   #0x40 
       sta   0,u 
P0B1A: jsr   P1BF4 
       ldx   #PlayerStandingStillLeftSide 
       stx   $C8AF     ; Set alternate vector list 2 
       lda   $C8F2     ; Use player's animation index to 
       asla             ; get the correct vector list. 
       ldx   #PlayerThrowing_RightSide_Table 
       ldx   a,x 
       stx   $C8AD     ; Set alternate vector list 1 
       bne   P0B34 
       clr   $C8C0 
       clr   $C8F2     ; When last vector list is reached 
       bra   P0B7C      ; reset player's animation index. 
P0B34: ldb   #0x7F      ; Calculate intensity 
       subb  $C8CC 
       subb  #0x10 
       lda   #0x70      ; Get scale value 
       std   $C8AB     ; Set intensity & scale values 
       ldd   #0x0000    ; Force drawing of alt vector lists 
       ldy   #0xC8CD    ; Set addr of drawing position 
       jsr   Draw2VectorLists 
       jmp   P0BB5 

; CheckForLRMovement()
;
; This function handles moving the player to the left or
; right, while fighting brigands.  It also takes care of
; drawing the 6 walls in the brigand area.
 
CheckForLRMovement:
       lda   $C81B     ; Get joystick l/r position 
       beq   P0B77      ; Do nothing, if in neutral 
       bmi   GoLeft     ; Branch if joystick is left 
GoRight:
       ldd   $C8EE     ; Get player's 16-bit x pos 
       cmpa  #0x0C      ; If not at upper bounds, then 
       bge   P0B6B      ; move player to the right. 
       addd  #0x0060 
       std   $C8EE     ; Update player's 16-bit x pos 
       bra   P0B69 
GoLeft:
       ldd   $C8EE     ; Get player's 16-bit x pos 
       cmpa  #0xF4      ; If not at lower bounds, then 
       ble   P0B6B      ; move player to the left 
       subd  #0x0060 
       std   $C8EE     ; Update player's 16-bit x pos 
P0B69: inc   $C88F 
P0B6B: lda   $C88F 
       beq   P0B77 
       lda   $C8A9     ; Is 'slow down' flag disabled? 
       bne   P0B79      ; Nope, so don't update 
       inc   $C8F2     ; Increment players animation index 
       bra   P0B79 
P0B77: clr   $C8F2     ; Reset player's animation index 
P0B79: jsr   P1BF4 
P0B7C: lda   $C8F2     ; Load player's animation index 
       ldx   #ImageFlip_Table 
       ldb   a,x 
       stb   $CBA0     ; Control flipping of image 
       asla 
       ldx   #PlyrSideStepping_LeftSide_Tbl 
       ldx   a,x 
       stx   $C8AF     ; Set alternate vector list 2 
       ldx   #PlyrSideStepping_RightSide_Tbl 
       ldx   a,x 
       stx   $C8AD     ; Set alternate vector list 1 
       bne   P0B9B 
       clr   $C8F2     ; Reset player's animation index 
       bra   P0B7C 
P0B9B: lda   #0x70      ; Calculate intensity 
       suba  $C8F0 
       cmpa  #0x20 
       ble   P0BB5 
       ldb   #0x7F      ; Calculate scale value 
       subb  $C8CC 
       subb  #0x10 
       std   $C8AB     ; Set intensity & scale values 
       ldd   #0x0000    ; Force drawing of alt vector lists 
       ldy   #0xC8CD    ; Set addr of drawing position 
       jsr   Draw2VectorLists 
P0BB5: lda   #0xD0 
       tfr   a,dp 
	direct $D0
       ldd   #0x0000 
       std   $C88F 
       clr   $CBA0     ; Don't flip image 
       ldd   #0x50FF 
       ldx   #BrigandWalls 
       ldy   #0xC88F 
       jsr   DT_MoveThenDraw 
       dec   $CBA0     ; Flip image 
       ldd   #0x50FF 
       ldx   #BrigandWalls 
       jsr   DT_MoveThenDraw 
       puls  dp,pc 

; UpdateFlamoids()
;
; This function processes all active flamoids.  Each active
; flamoid is checked to see if it has gone off the display,
; and if so, is deactivated.  The lifespan value is
; decremented, to see if the flamoid should be deactivated.
; Otherwise, a random angle is used to transform the flamoid
; vector list (to give the impression it is spinning), and
; the flamoid is drawn.
 
UpdateFlamoids:
       pshs  dp 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       ldx   #Flamoid 
       ldu   #0xC9A4       ; Transform buffer 
       lda   $C826        ; Calculate random angle 
       asla 
       asla 
       ldb   ,x+           ; Get # of endpoints 
       stb   ,u+           ; Also save in xform buffer 
       jsr   DROT
       ldd   #0x0080 
       std   $C837        ; Force 'run' index pair 
       ldd   #0xFF81 
       std   $C839        ; Force 'rise' index pair 
       ldu   #0xC9F8       ; Get ptr to flamoid array 
       lda   #0x08 
       sta   $C88F        ; Process 8 entries 
P0C05: lda   0,u           ; Skip, if entry not active 
       beq   P0C41 
       jsr   UpdatePosition 
       bvs   P0C3F         ; Disable flamoid, if it went 
       blo   P0C3F         ; off the display. 
       lda   5,u           ; Load hi-byte of y position 
       ldb   7,u           ; Load hi-byte of x position 
       sta   $C8CA 
       stb   $C8C8 
       lda   9,u 
       sta   $C8C9 
       jsr   TransformPoint 
       bvs   P0C41 
       dec   10,u          ; Decrement flamoid's lifespan 
       beq   P0C3F 
       pshs  dp 
       lda   #0xD0 
       tfr   a,dp 
	direct $D0
       ldx   #0xC9A4       ; Xformed flamoid vector list 
       ldd   #0x7F7F       ; Calculate intensity & scale 
       subb  $C8CC 
       ldy   #0xC8CD       ; Address of drawing position 
       jsr   DT_MoveThenDraw 
       puls  dp 
	direct $C8
       bra   P0C41 
P0C3F: clr   0,u          ; Mark entry as now inactive 
P0C41: leau  11,u         ; Keep processing the entries, 
       dec   $C88F       ; until there are no more. 
       bne   P0C05 
       puls  dp,pc 

; ProcessExplodingObjects()
;
; This function processes any active explosions (i.e. the
; player or a brigand exploding into pieces).  Each 
; exploding component has its angle of rotation updated
; (pieces appear to spin off during an explosion), along
; with its intensity (components get dimmer over time).
 
ProcessExplodingObjects:
       pshs  dp 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       clr   $CBA0       ; Don't flip image 
       clr   $C9A3 
       ldu   #0xCA50      ; Get ptr to explosion bfr array 
       lda   #0x0E 
       sta   $C88F       ; Set loop counter 
P0C5C: lda   0,u 
       beq   P0CA7        ; Skip if entry is inactive 
       dec   14,u         ; Decrement lifespan; skip if 
       beq   P0CA5        ; lifespan decrements to 0. 
       lda   $C9A3 
       ora   14,u 
       sta   $C9A3 
       jsr   UpdatePosition 
       bvs   P0CA5        ; Disable, if it went off the 
       blo   P0CA5        ; display. 
       pshs  u 
       lda   10,u         ; Update angle value 
       adda  11,u 
       anda  #0x3F        ; Force in range 0-359 degrees 
       sta   10,u 
       ldx   12,u         ; Get the vector list 
       ldu   #0xC9A4      ; Transform buffer 
       ldb   ,x+          ; Get number of endpoints 
       stb   ,u+          ; Also save into xform buffer 
       andb  #0x3F 
       jsr   DROT
       puls  u 
       pshs  dp 
       lda   #0xD0 
       tfr   a,dp 
	direct $D0
       ldx   #0xC9A4      ; Transform buffer 
       lda   14,u         ; Calculate decreasing intensity 
       adda  #0x30 
       ldb   9,u          ; Set drawing scale factor 
       leay  5,u          ; Set drawing position 
       jsr   DT_16bitMoveThenDraw 
       puls  dp 
	direct $C8
       bra   P0CA7 
P0CA5: clr   0,u          ; Disable this entry 
P0CA7: leau  15,u         ; Point to next entry 
       dec   $C88F       ; Process next entry, if any 
       bne   P0C5C 
       puls  dp,pc 

; CheckFlamoidsForHits()
;
; This processes each active flamoid, to see if it has
; come in contact with the player, a brigand or a wall.
 
CheckFlamoidsForHits:
       pshs  dp 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       ldu   #0xC9F8     ; Get ptr to flamoid array 
       lda   #0x08 
       sta   $C88F      ; Set loop counter 
P0CBC: lda   0,u         ; Skip this flamoid, if it is 
       lbeq  P0DF5       ; not active. 
       lda   5,u         ; Get y position 
       ldb   7,u         ; Get x position 
       std   $C883      ; Save position for later use 
       lda   0,u 
       bita  #0x40 
       bne   CheckForHitOnWall 
       lda   $C8EB      ; Skip, if player is dead 
       beq   CheckForHitOnWall 

; CheckForHitOnPlayer()
;
; Tests to see if a flamoid thrown by a brigand has hit
; the players.  If so, then the player is added to the
; explosion buffer, and he is flagged as dead.
 
CheckForHitOnPlayer:
       ldx   $C883      ; Get bullet position 
       lda   $C8EC      ; Get player's y position 
       ldb   $C8EE      ; Get player's x position 
       tfr   d,y         ; Set player as the target 
       ldd   #0x0202     ; Size of target area / 2 
       jsr   BXTEST
       bhs   CheckForHitOnWall  ; Branch if no hit occurred 
       pshs  x,y,u 
       clrb 
       lda   $C8D0 
       tfr   d,y 
       lda   $C8D1 
       tfr   d,x 
       lda   #0x3F 
       ldu   #PlayerExploding_Head 
       jsr   RegisterNewExplosionEntry 
       ldu   #PlayerExploding_LeftArm 
       jsr   RegisterNewExplosionEntry 
       ldu   #PlayerExploding_RightArm 
       jsr   RegisterNewExplosionEntry 
       ldu   #PlayerExploding_Body 
       jsr   RegisterNewExplosionEntry 
       clr   $C8EB      ; Flag that player is dead 
       lda   #0x7F 
       sta   $C89C      ; Reset startup delay counter 
       inc   $C9A3 
       lda   #0x80 
       sta   $CB70 
       puls  x,y,u 
       jmp   P0DF3 

; CheckForHitOnWall()
;
; This function tests to see if the flamoid has come
; in contact with any of the 6 walls in the brigand
; area.  If it has, then the flamoid is marked as
; inactive.
 
CheckForHitOnWall:
       ldx   $C883     ; Get bullet position 
       ldy   #0x52E0    ; Set target position 
       ldd   #0x030A    ; Get target size / 2 
       jsr   BXTEST
       lblo  P0DF3 
       ldx   $C883     ; Get bullet position 
       ldy   #0x5EE8    ; Set target position 
       ldd   #0x0306    ; Get target size / 2 
       jsr   BXTEST
       lblo  P0DF3 
       ldx   $C883     ; Get bullet position 
       ldy   #0x66E8    ; Get target position 
       ldd   #0x0309    ; Get target size / 2 
       jsr   BXTEST
       lblo  P0DF3 
       ldx   $C883     ; Get bullet position 
       ldy   #0x5218    ; Get target position 
       ldd   #0x0302    ; Get target size / 2 
       jsr   BXTEST
       lblo  P0DF3 
       ldx   $C883     ; Get bullet position 
       ldy   #0x5E18    ; Get target position 
       ldd   #0x0306    ; Get target size / 2 
       jsr   BXTEST
       lblo  P0DF3 
       ldx   $C883     ; Get bullet position 
       ldy   #0x6618    ; Get target position 
       ldd   #0x0308    ; Get target size 
       jsr   BXTEST
       blo   P0DF3 

; CheckForHitOnBrigand()
;
; This function loops through each of the flamoids, to
; see if a brigand has been hit.  A brigand is only
; vulnerable when he is fully exposed.  If a brigand is
; hit, then he will be added to the explosion buffer,
; the flamoid will be made inactive, and the player will
; be awarded 125 points.
 
CheckForHitOnBrigand:
       ldy   #0xC9E0    ; Get ptr to brigand array 
       lda   #0x06 
       sta   $C890     ; Set loop counter 
P0D80: lda   0,y 
       bpl   P0DEB 
       ldx   #BrigandIsVulnerable  ; It is only possible to 
       lda   1,y        ; hit the brigand when he is fully 
       lda   a,x        ; exposed; check if he is. 
       beq   P0DEB      ; Nope; so don't check for a hit 
       lda   0,u        ; Get flamoid state information 
       bita  #0x40 
       beq   P0DEB 
       pshs  y,u 
       ldx   2,y        ; Get ptr to brigand position info 
       lda   9,x 
       ldb   11,x 
       ldx   15,x       ; Get target size information 
       pshs  x 
       tfr   d,y        ; Save target position 
       lda   5,u        ; Get flamoid y position 
       ldb   7,u        ; Get flamoid x position 
       tfr   d,x        ; Save bullet position 
       puls  a,b 
       jsr   BXTEST
       puls  y,u 
       bhs   P0DEB      ; Branch if no hit occurred 
       pshs  y,u 
       ldx   2,y        ; Get ptr to brigand position info 
       ldy   0,x        ; Load brigand's y position 
       lda   14,x 
       ldx   2,x        ; Load brigand's x position 
       ldu   #BrigandExploding_RightArm 
       jsr   RegisterNewExplosionEntry 
       ldu   #BrigandExploding_LeftArm 
       jsr   RegisterNewExplosionEntry 
       ldu   #BrigandExploding_Head 
       jsr   RegisterNewExplosionEntry 
       puls  y,u 
       clr   0,u        ; Flag flamoid as inactive 
       ldx   #0xCB3A    ; Add 125 to player's score 
       ldd   #0x0125 
       jsr   SCRADD
       inc   $C9A3 
       lda   #0x80 
       sta   $CB6F 
       clr   0,y 
       dec   $C8E9 
       lda   #0x01 
       sta   $C9A1 
P0DEB: leay  4,y        ; Point to next brigand entry 
       dec   $C890     ; Decrement loop counter 
       bne   P0D80      ; Process next brigand entry 
       bra   P0DF5 
P0DF3: clr   0,u        ; Tag flamoid as inactive 
P0DF5: leau  11,u       ; Point to next flamoid entry 
       dec   $C88F     ; Decrement loop counter 
       lbne  P0CBC      ; Process next flamoid entry 
       puls  dp,pc 

; InsideMagicianChest()
;
; This functions controls the game, while the player is
; inside of a treasure chest containing a magician.
; It moves the player into the chest, animates the magician
; and then determines whether or not anything will be
; awarded to the player.
 
	direct $D0
InsideMagicianChest:
       jsr   PreserveVisibleObjectData 
       jsr   ClearAllGameStorageArrays 
       pshs  dp 
       jsr   SetPlayersPositionInChest 
       lda   #0x80 
       sta   $CB89     ; Flag start of dot sequence 
       lda   #0x3F 
       sta   $CB8A 
       lda   #0x1F 
       sta   $CB8B 
P0E19: jsr   CheckForInventoryRequest 
       lda   $CB8B 
       beq   P0E26 
       dec   $CB8B 
       bra   P0E2F 
P0E26: ldd   #0xCD00    ; Use fixed (y,x) position 
       jsr   DrawDotsIfActive 
       sta   $C8F0 
P0E2F: jsr   CheckForFiringOrMovement 
       lda   $CB89     ; Jump if the dot sequence 
       bne   P0E19      ; has not completed. 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       lda   #0x80 
       sta   $CB89     ; Flag start of dot sequence 
       lda   #0x3F 
       sta   $CB8A 
       lda   #0x68 
       sta   $CB8B 
       lda   #0x7F 
       sta   $C9A1 
       ldu   #0xFF26 
       jsr   SPLAY
P0E55: jsr   CheckForInventoryRequest 
       lda   $CB8B 
       beq   P0E62 
       dec   $CB8B 
       bra   P0E6B 
P0E62: ldd   #0x1000       ; Use fixed (y,x) position 
       jsr   DrawDotsIfActive 
       sta   $C9A1 
P0E6B: clr   $C9A0        ; Clear magician animation index 
       jsr   DrawMagician 
       jsr   CheckForFiringOrMovement 
       lda   $CB89        ; Jump if the dot sequence 
       bne   P0E55         ; has not completed. 
       clr   $C9A0 
       clr   $C9A2 
P0E7F: jsr   CheckForInventoryRequest 
       jsr   DrawAnimatedMagician 
       jsr   CheckForFiringOrMovement 
       lda   $C9A2 
       bne   P0E8F 
       bra   P0E7F 
P0E8F: lda   #0xC8 
       tfr   a,dp 
	direct $C8
       jsr   RANDOM        ; Random # decides if player 
       cmpa  #0x80         ; has chance for award, or goes 
       bls   AttemptMagicianAward  ; away empty handed. 
       cmpa  #0x90 
       lbls  NoMagicianAward 

; AttemptMagicianAward()
;
; This function attempts to award the player something
; useful, like a key, a scout, a healer or a warrior.  The 
; award given is dependent upon how much gold the player has.
; The more gold available, the better the award.  Also,
; if the player already has a certain item, then the
; next best item will be awarded.  After an award is
; made, the player is left with only a few bags of gold.
 
AttemptMagicianAward:
       ldd   $C8DD        ; Player must have at least 
       cmpd  #0x0060       ; 60 bags of gold to get the 
       blt   P0EAF         ; Gold Key. 
       jsr   AwardGoldKey 
       lbne  ChargePlayerForAward 
P0EAF: ldd   $C8DD        ; Player must have at least 
       cmpd  #0x0060       ; 60 bags of gold to get the 
       blt   P0EBC         ; Crystal Crown. 
       jsr   AwardCrystalCrown 
       bne  ChargePlayerForAward 
P0EBC: ldd   $C8DD        ; Player must have at least 
       cmpd  #0x0050       ; 50 bags of gold to get the 
       blt   P0EC9         ; Silver Key. 
       jsr   AwardSilverKey 
       bne   ChargePlayerForAward 
P0EC9: ldd   $C8DD        ; Player must have at least 
       cmpd  #0x0040       ; 40 bags of gold to get the 
       blt   P0ED6         ; Bronze Key. 
       jsr   AwardBronzeKey 
       bne   ChargePlayerForAward 
P0ED6: ldd   $C8DD        ; Player must have at least 
       cmpd  #0x0030       ; 30 bags of gold to get the 
       blt   P0EE3         ; Brass Key. 
       jsr   AwardBrassKey 
       bne   ChargePlayerForAward 
P0EE3: ldd   $C8DD        ; Player must have at least 
       cmpd  #0x0020       ; 20 bags of gold to get the 
       blt   P0F02         ; Scout. 
       lda   $C8DB        ; Skip, if already has a Scout 
       bne   P0F02 
       inc   $C8DB        ; Flag that Scout was awarded 
       lda   #0x04         ; Allow upto 4 uses of the scout 
       sta   $C8C2        ; before he is used up. 
       ldx   #0xCB3A       ; Add 300 to player's score 
       ldd   #0x0300 
       jsr   SCRADD
       lda   #0x0C         ; Show that bonus was awarded 
       bra   ChargePlayerForAward 
P0F02: ldd   $C8DD        ; Player must have at least 
       cmpd  #0x0015       ; 15 bags of gold to get the 
       blt   P0F21         ; Healer. 
       lda   $C8DC        ; Skip, if already has a healer 
       bne   P0F21 
       inc   $C8DC        ; Flag that Healer was awarded 
       lda   #0x04         ; Allow upto 4 uses of healer 
       sta   $C8C3        ; before he is used up. 
       ldx   #0xCB3A       ; Add 300 to player's score 
       ldd   #0x0300 
       jsr   SCRADD
       lda   #0x0E         ; Show that bonus was awarded 
       bra   ChargePlayerForAward 
P0F21: ldd   $C8DD 
       cmpd  #0x0010          ; Player must have at least 
       blt   NoMagicianAward  ; 10 bags of gold to get an 
       jsr   AwardNewWarrior  ; extra warrior. 
       bne   ChargePlayerForAward 

; NoMagicianAward()
;
; When the player enters a magician chest, he has a random
; chance of coming away empty handed.  He will also come
; away empty handed if he does not have at least 10 bags
; of gold.  This function displays the 'Be Gone' label,
; which tells the player he got nothing.
 
NoMagicianAward:
       clra                ; No award made; 'Be Gone' 
       jsr   SetLabelOfFoundObject 
       bra   DisplayMagicianAward 

; ChargePlayerForAward()
;
; When the magician awards something to the player, he
; takes most of the player's gold, leaving him with only
; 2-9 bags of gold.
 
ChargePlayerForAward:
       jsr   SetLabelOfFoundObject 
       ldx   #BagsOfGoldLabel_2 
       ldu   #0xCB4B 
       jsr   CopyStringToBuffer 
       jsr   RANDOM
       anda  #0x07         ; When an award occurs, the 
       adda  #0x02         ; player is 'charged' for it. 
       sta   $C8DE        ; The player is then left with 
       clr   $C8DD        ; only 2-9 bags of gold. 
       ora   #0x30         ; Need to update the player's 
       sta   $CB4E        ; gold count in inventory list. 

; DisplayMagicianAward()
;
 
	direct $D0
DisplayMagicianAward:
       lda   #0x01 
       sta   $CB89        ; Flag start of dot sequence 
       clr   $CB8A 
       lda   #0x0F 
       sta   $CB8B 
P0F5D: jsr   CheckForInventoryRequest 
       lda   $CB8B 
       beq   P0F6A 
       dec   $CB8B 
       bra   P0F73 
P0F6A: ldd   #0x1000       ; Load fixed (y,x) location 
       jsr   DrawDotsIfActive 
       sta   $C9A1 
P0F73: jsr   DrawEnlargingString 
       jsr   DrawMagician 
       jsr   CheckForFiringOrMovement 
       lda   $CB89        ; Jump if the dot sequence 
       bne   P0F5D         ; has not completed. 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       lda   #0x01 
       sta   $CB89        ; Flag start of dot sequence 
       clr   $CB8A 
       lda   #0x0F 
       sta   $CB8B 
P0F92: jsr   CheckForInventoryRequest 
       lda   $CB8B 
       beq   P0F9F 
       dec   $CB8B 
       bra   P0FA8 
P0F9F: ldd   #0xCD00       ; Load fixed (y,x) location 
       jsr   DrawDotsIfActive 
	direct $D0
       sta   $C8F0 
P0FA8: jsr   DrawEnlargingString 
       jsr   CheckForFiringOrMovement 
       lda   $CB89       ; Jump if the dot sequence 
       bne   P0F92        ; has not completed. 
       jmp   P09DB 

; DrawAnimatedMagician()
; DrawMagician()
;
; DrawAnimatedMagician() draws the magician in an animated
; fashion, using C9A0 as the animation index, and incrementing
; it before drawing.
;
; DrawMagician() draws the magician using C9A0 as the
; animation index, but does not modify the index value.
 
	direct $D0
DrawAnimatedMagician:
       lda   $C8A8     ; Is 'slow down' flag disabled? 
       bne   DrawMagician   ; Nope, so don't update 
       inc   $C9A0     ; Increment animation index 
DrawMagician:
       lda   $C9A0     ; Use animation index to get the 
       asla             ; correct vector lists. 
       ldx   #MagicianLeftSide_Table 
       ldx   a,x 
       stx   $C8AF    ; Set alternate vector list 1 
       ldx   #MagicianRightSide_Table 
       ldx   a,x 
       stx   $C8AD     ; Set alternate vector list 1 
       bne   P0FDE      ; When last vector list reached, 
       dec   $C9A0     ; repeat previous 1 again. 
       lda   #0x01 
       sta   $C9A2 
       bra   DrawMagician 
P0FDE: lda   #0x70      ; Calculate intensity value 
       suba  $C9A1     ; Make some adjustments 
       cmpa  #0x20 
       ble   P0FFC      ; Skip if intensity < 0x20 
       ldb   #0x50      ; Calculate scale factor 
       std   $C8AB     ; Set intensity & scale values 
       ldd   #0x1000 
       std   $C88F     ; Set drawing position 
       ldd   #0x0000    ; Force drawing of alt vector lists 
       ldy   #0xC88F    ; Set addr of drawing position 
       jsr   Draw2VectorLists 
P0FFC: rts 

; TryToSolveRiddleOfKeys()
;
; Give the player the opportunity to order the keys, to
; solve the solution of the puzzle.  Once the player
; signals that the solution should be checked, check the
; solution and either let them know it is solved, or
; move them back out of the tower, and allow them to
; try again.
 
TryToSolveRiddleOfKeys:
       pshs  dp,y,u 
       jsr   PreserveVisibleObjectData 
       jsr   ClearAllGameStorageArrays 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       clr   $CBA0        ; Don't flip image 
P100C: jsr   CheckForInventoryRequest 
	direct $D0
       lda   $C813       ; Get console 1, btn 2 state 
       beq   P101D 
       ldb   $C9A4       ; Move selection arrow 
       incb 
       andb  #0x03        ; Force in range 0-3 
       stb   $C9A4       ; Update arrow position 
P101D: lda   $C814       ; Get console 1, btn 3 state 
P1020: beq   P1037 
       ldu   #0xC9A0      ; Cycle to the next key choice. 
       lda   #0x03        ; Get the index of the current 
       suba  $C9A4       ; choice for this position in ;
       leau  a,u          ; the solution, and increment 
       ldb   ,u           ; increment it, thus selecting 
       incb               ; the next key.  If wrapping 
       cmpb  #0x04        ; needs to take place, then 
       bls   P1035        ; wrap to key 1 (gold). 
       ldb   #0x01 
P1035: stb   ,u           ; Save the new value 
P1037: lda   $C815       ; Get console 1, btn 4 state 
       lbne  TestRiddleSolution 
P103E: jsr   INTMAX
       ldu   #RiddleOfTheKeysLabel 
       jsr   PrintMultiPartString 
       ldd   #0xC0C4        ; Get drawing position 
       jsr   POSITD
       ldb   #0xE0          ; Scale factor 
       ldx   #TowerDoor 
       jsr   DT_Draw        ; Draw tower door 
       jsr   INT3Q
       ldd   #0x1020        ; Get drawing position 
       jsr   POSITD
       ldb   #0xA0          ; Scale factor 
       ldx   #KeyHole 
       jsr   DT_Draw        ; Draw tower door keyhole 
       ldd   #0xB290 

; This block displays the player's choices (names of keys)
; for each of the 4 positions making up the solution to
; the riddle of the keys.  It loops, once for each of the 
; solution positions.
 
       std   $C88F        ; Set initial icon drawing pos 
       ldd   #0xA880 
       std   $C891        ; Set initial text drawing pos 
       lda   #0x03 
       sta   $C893        ; Set loop counter for 4 passes 
P1077: jsr   INT3Q
       ldd   $C88F 
       addb  #0x2E         ; Update icon drawing position 
       std   $C88F        ; Get drawing position 
       jsr   POSITD
       ldb   #0x38         ; Set scale factor 
       ldx   #Key 
       jsr   DT_Draw       ; Draw the key icon 
       ldd   #0xFC30 
       std   $C82A        ; Set text height & width 
       jsr   INTMAX
       ldd   $C891 
       addb  #0x2E         ; Update text drawing position 
       std   $C891        ; Get drawing position 
       jsr   POSITD
       ldu   #0xC9A0       ; Get the index of the next 
       lda   $C893        ; key in player's solution. 
       lda   a,u 
       ldu   #KeyNameLabelTable 
       asla                ; Get the label for the key 
       ldu   a,u           ; Print name of this key 
       jsr   RASTER
       dec   $C893        ; Decrement loop counter 
       bpl   P1077 
       ldu   #ArrowXpositions 
       lda   $C9A4        ; Get location of arrow 
       ldb   a,u           ; Set x position 
       lda   #0x98         ; Set y position 
       jsr   POSITD
       ldb   #0x14         ; Set scale factor 
       ldx   #Arrow 
       jsr   DT_Draw       ; Draw selection arrow 
       jmp   P100C 

; TestRiddleSolution()
;
; Compare the player's guess against the predetermined
; solution.  If they match, then the game is over.
; Otherwise, show them which keys are correct, then
; place the player back outside the tower, or randomly
; in the forest (if he does not have a scout).
 
TestRiddleSolution:
       ldx   #0xC99C       ; Ptr to real solution 
       ldu   #0xC9A0       ; Ptr to player's guess 
       ldb   #0x03         ; First, verify that each 
       lda   ,u            ; key was used only once; 
       adda  1,u           ; the sum of the key indices 
       adda  2,u           ; should be 10 (1+2+3+4). 
       adda  3,u 
       cmpa  #0x0A         ; All 4 keys in place? 
       lbne  P103E         ; Nope 
P10E5: lda   b,x           ; Compare the order against 
       cmpa  b,u           ; the solution. 
       bne   IncorrectAnswer ; Bail if a mismatch occurs 
       decb                ; Decrement loop counter 
       bpl   P10E5         ; Check remaining keys 
       jmp   SolutionMatches ; The solutions match!! 

; IncorrectAnswer()
;
; The player's guess was wrong.  Briefly show them which
; keys were correct, and then drop them back into the
; forest.
 
IncorrectAnswer:
       lda   #0xC8         ; Incorrect solution 
       tfr   a,dp 
	direct $C8
       clr   $CBA0        ; Don't flip image 
       lda   #0x50 
       sta   $C8EA        ; Set duration counter 
P10FC: jsr   CheckForInventoryRequest 
	direct $D0
       jsr   INTMAX
       ldd   #0xC0C4       ; Set drawing position 
       jsr   POSITD
       ldb   #0xE0         ; Set scale factor 
       ldx   #TowerDoor 
       jsr   DT_Draw       ; Draw tower door 
       jsr   INT3Q
       ldd   #0x1020       ; Set drawing position 
       jsr   POSITD
       ldb   #0xA0         ; Set scale factor 
       ldx   #KeyHole 
       jsr   DT_Draw       ; Draw the keyhole 
       ldd   #0xB290 
       std   $C88F        ; Set initial drawing position 
       ldd   #0xA880 
       std   $C891        ; Set initial text position 
       lda   #0x03 
       sta   $C893        ; Set loop counter; 4 passes 
       ldd   #0xFC30 
       std   $C82A        ; Set string height & width 
P1138: ldd   $C88F        ; Retrieve saved drawing pos 
       addb  #0x2E         ; Adjust 'x' for next icon 
       std   $C88F        ; Save modified drawing position 
       ldd   $C891        ; Retrieve saved text position 
       addb  #0x2E         ; Adjust 'x' for next string 
       std   $C891        ; Increment text position 
       jsr   INT3Q
       ldd   $C88F        ; Set drawing position 
       jsr   POSITD
       ldb   #0x38         ; Set scale factor 
       ldx   #Key 
       jsr   DT_Draw       ; Draw the key icon 
       ldx   #0xC99C       ; Sequence thru each key; if 
       lda   $C893        ; it was positioned correctly, 
       ldb   a,x           ; then keep displaying the key 
       ldx   #0xC9A0       ; label, so player will know it. 
       cmpb  a,x 
       bne   P1182         ; This key was in wrong order 
       jsr   INTMAX         ; Key in correct order 
       ldu   #0xC99C       ; Get the label for the key 
       lda   $C893        ; which was in the correct 
       lda   a,u           ; order. 
       ldu   #KeyNameLabelTable 
       asla 
       ldu   a,u 
       ldd   $C891        ; Set drawing position 
       jsr   POSITD
       jsr   RASTER        ; Display key name 
P1182: dec   $C893        ; Decrement loop counter 
       bpl   P1138         ; Anymore keys to process? 
       dec   $C8EA        ; Decrement duration counter 
       lbne  P10FC         ; Keep looping for awhile 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       jsr   ClearAllGameStorageArrays 
       jsr   FillInVisibleForestInfo 
       jsr   RestoreVisibleObjectData 
	direct $D0
       puls  dp,y,u,pc 
 
; SolutionMatches()
;
; The solution matches!  Draw the player walking into the
; dark tower, followed by the 'Game Over' string.
 
SolutionMatches:
       lda   #0xC8         ; The block copy done below do 
       tfr   a,dp          ; nothing more than use up time. 
	direct $C8
       ldu   #0xC8F8       ; Work buffer 
       lda   #0x10 
       sta   $C890        ; Set loop counter 
P11A8: ldx   #0xC8D6       ; Table of player's possessions 
       ldd   #0xFF00 
       std   ,u++ 
       clr   $C88F        ; Clear the checksum 
P11B2: lda   ,x+           ; Copy the player's possessions 
       sta   ,u+           ; into a backup buffer. 
       adda  $C88F
       sta   $C88F        ; Update checksum 
       cmpx  #0xC8DF       ; Everything copied? 
       ble   P11B2         ; Nope ... keep going 
       ldb   #0x03         ; Set loop counter 
       ldy   #0xCB4B       ; "    x Bags Of Gold" buffer 
P11C5: lda   ,y+           ; Copy first 4 bytes into the 
       sta   ,u+           ; buffer also. 
       adda  $C88F 
       sta   $C88F        ; Update the checksum 
       decb                ; All bytes copied? 
       bpl   P11C5         ; Nope ... keep going 
       ldb   #0x03         ; Set loop counter 
       ldy   #0xCB8C       ; "   x Reserve Troops" buffer 
P11D6: lda   ,y+           ; Copy first 4 bytes into the 
       sta   ,u+           ; buffer also. 
       adda  $C88F 
       sta   $C88F        ; Update the checksum 
       decb                ; All bytes copied? 
       bpl   P11D6         ; Nope ... keep going 
       ldb   #0x06         ; Set loop counter 
       ldy   #0xCB3A       ; "Your Score Is     x" string 
P11E7: lda   ,y+           ; Copy the 7 bytes of score 
       sta   ,u+           ; into the buffer also. 
       adda  $C88F 
       sta   $C88F        ; Update the checksum 
       decb                ; All bytes copied? 
       bpl   P11E7         ; Nope ... keep going 
       lda   $C88F 
       sta   ,u+           ; Save the checksum 
       dec   $C890        ; Repeat, until loop counter 
       bne   P11A8         ; decrements to 0. 
       ldu   #DT_IntroMusic 
       jsr   SPLAY         ; Play intro music 
       ldx   #0xCB3A       ; Add 3000 to player's score 
       ldd   #0x3000 
       jsr   SCRADD
       lda   #0xFF 
       ldb   #0x30 
       std   $C896        ; Set player's intensity & scale 
       clr   $C898        ; Use 16-bits of scale 
       ldd   #0xE000 
       std   $C8EC        ; Set player's 16-bit y pos 
P1216: jsr   CheckForInventoryRequest 
	direct $D0
       ldu   #EnterVictoriousWarriorLabel 
       jsr   PrintMultiPartString 
       ldd   #0x48FF 
       std   $C8AB        ; Set tower intensity & scale 
       ldd   #0xF000 
       std   $C88F        ; Set tower drawing position 
       clr   $CBA0        ; Don't flip tower image 
       ldd   #DarkTowerRightHalf   ; Set vector list 1 
       ldx   #DarkTowerLeftHalf    ; Set vector list 2 
       ldy   #0xC88F       ; Set addr of drawing position 
       jsr   Draw2VectorLists 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       dec   $C896        ; Decrement player's intensity 
       lda   $C896        ; As the player's intensity 
       bmi   P1259         ; decreases, draw the player 
       cmpa  #0x20         ; differently. 
       ble   P1264 

; Draw player walking into the Dark Tower 
       sta   $C8AB        ; Update player's intensity value 
       ldd   $C897 
       subd  #0x0020 
       std   $C897        ; Decrement player's 16-bit scale 
       sta   $C8AC        ; Update player's scale value 
       jsr   DrawPlayerWalking 
       bra   P1216 

; Draw player apprehensively approaching the Dark Tower 
P1259: lda   #0x7F 
       ldb   #0x30 
       std   $C8AB        ; Set intensity & scale values 
       jsr   PlayerStandingStill 
       bra   P1216 

; Stop drawing the player, and show 'Game Over' 
P1264: jsr   CheckForInventoryRequest 
	direct $D0
       ldd   #0x48FF 
       std   $C8AB        ; Set intensity & scale values 
       ldd   #0xF000 
       std   $C88F        ; Set tower drawing position 
       clr   $CBA0        ; Don't flip image 
       ldd   #DarkTowerRightHalf   ; Set vector list 1 
       ldx   #DarkTowerLeftHalf    ; Set vector list 2 
       ldy   #0xC88F       ; Set addr of drawing position 
       jsr   Draw2VectorLists 
       jsr   DisplayGameOverInfo 
       bra   P1264 

; CheckForInventoryRequest()
;
; As long as button 1 on console 1 is pressed, display
; the player's inventory information.
 
CheckForInventoryRequest:
       lda   #0xD0 
       tfr   a,dp 
	direct $D0
       jsr   INTMAX
       lda   $C812        ; Get console 1, btn 1 state 
       lbeq  DoMainProcessing  ; Skip if btn 1 not pressed 
       lda   $C856 
       ora   $CB6C 
       ora   $CB6D 
       ora   $CB6E 
       ora   $CB6F 
       ora   $CB70 
       lbne  DoMainProcessing 
       pshs  dp 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       lda   #0x80 
       jsr   P14E5 
       puls  dp 
	direct $D0
       ldd   #0x64A0      ; Set drawing position 
       jsr   POSITD
       ldd   #0xF638      ; Set text drawing H & W values 
       std   $C82A 
       ldu   #0xCB2C      ; Print "Your score is ..." 
       jsr   RASTER
       ldd   #0x4CA0      ; Set drawing position 
       jsr   POSITD
       ldd   #0xF638 
       std   $C82A       ; Set text drawing H & W values 
       ldu   #InventoryLabel 
       jsr   RASTER       ; Display "Player Inventory" 
       ldd   #0x38B8 
       std   $C891       ; Set initial text position 
       lda   $C8DF       ; Display # of reserve troops, if 
       beq   P130E        ; there are any. 
       ldd   $C891       ; Set drawing position 
       jsr   POSITD
       ldd   #0xF838      ; Set text drawing H & W values 
       std   $C82A 
       ldu   #0xCB8C 
P12F7: lda   ,u           ; Strip off leading spaces and 
       ora   #0x10        ; zeros from the number of 
       cmpa  #0x30        ; reserve troops; display the 
       bne   P1303        ; modified value 
       leau  1,u 
       bra   P12F7 
P1303: jsr   RASTER       ; Display # of reserve troops 
       ldd   $C891 
       suba  #0x10 
       std   $C891       ; Update text drawing position 
P130E: ldd   $C891       ; Set drawing position 
       jsr   POSITD
       ldd   #0xF838 
       std   $C82A       ; Set text drawing H & W values 
       ldu   #0xCB4B      ; Strip off leading spaces and 
P131D: lda   ,u           ; zeros from the number of bags 
       ora   #0x10        ; of gold the player has; display 
       cmpa  #0x30        ; the modified value. 
       bne   P1329 
       leau  1,u 
       bra   P131D 
P1329: jsr   RASTER       ; Display # of bags of gold 
       ldd   $C891 
       suba  #0x10 
       std   $C891       ; Update text drawing position 
       ldd   #0xFA38 
       std   $C82A       ; Set text drawing H & W values 
       lda   #0x07 
       sta   $C88F       ; Set loop counter 
       ldy   #0xC8D6      ; Array of player's possessions 
       clr   $C890       ; Index into player's possessions 
P1346: lda   $C890 
       lda   a,y          ; See if player has this object? 
       beq   P1369        ; Skip, if answer is 'no' 
       ldd   $C891       ; Set drawing position 
       jsr   POSITD
       ldu   #TableOfObjectsToFind 
       lda   $C890 
       asla 
       adda  #0x02 
       ldu   a,u          ; Get label for this object 
       jsr   RASTER
       lda   $C891 
       suba  #0x10 
       sta   $C891       ; Update text drawing position 
P1369: inc   $C890 
       dec   $C88F       ; Decrement loop counter 
       bne   P1346        ; Keep processing? 
       jsr   FRWAIT 
       jsr   DEFLOK 
       jsr   DEFLOK 
       jsr   DEFLOK 
       jsr   RANDOM
       lda   $C880       ; Load console button mask 
       jsr   DBNCE        ; Keep displaying inventory 
       jmp   CheckForInventoryRequest  ; until button 1 
			  ; is released. 

	direct $D0
DoMainProcessing:
       jsr   FRWAIT
       pshs  dp 
       jsr   DEFLOK 
       lda   $C880       ; Load console button mask 
       jsr   DBNCE
       ldd   $C881      ; Configure the joystick: 
       std   $C81F      ;    console 1 l/r => C81B 
       std   $C821      ;    console 1 u/d => C81C 
       jsr   JOYBIT
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       lda   $C826       ; Grab a random number 
       anda  #0x07       ; Set 'slow down' counter; allows 
       sta   $C8A8       ; updates only every 7th pass. 
       anda  #0x03       ; Set 'slow down' counter; allows 
       sta   $C8A9       ; updates only every 4th pass. 
       anda  #0x01 
       sta   $C8AA 
       lda   $C89C      ; The following block causes the 
       beq   P13C1       ; function pointed to by C89D to 
       dec   $C89C      ; be called only once, when C89C 
       bne   P13C1       ; decrements to zero. 
       jsr   [ $C89D ]; (INDIRECT JUMP) 
P13C1: lda   $C89F      ; The following block causes the 
       beq   P13CD       ; function pointed to by C8A0 to 
       dec   $C89F      ; be called only once, when C89F 
       bne   P13CD       ; decrements to zero. 
       jsr   [ $C8A0 ]; (INDIRECT JUMP) 
P13CD: lda   $C8A2      ; The following block causes the 
       beq   P13D9       ; function pointed to by C8A3 to 
       dec   $C8A2      ; be called only once, when C8A2 
       bne   P13D9       ; decrements to zero. 
       jsr   [ $C8A3 ]; (INDIRECT JUMP) 
P13D9: lda   $C856 
       beq   P13F2 
       clr   $CB6D 
       clr   $CB6C 
       clr   $CB6E 
       clr   $CB6F 
       clr   $CB70 
       jsr   REPLAY
       jmp   P14DF 
P13F2: lda   #0x80 
       jsr   P14E5 
       lda   $CB6C 
       bne   P1421 
       lda   $CB6D 
       bne   P144C 
       lda   $CB70 
       lbmi  P14B5 
       lbne  P14CA 
       lda   $CB6F 
       lbmi  P149D 
       lda   $CB6E 
       lbmi  P1483 
       lbne  P1498 
       jmp   P14CD 
P1421: lda   #0x03 
       jsr   P14E5 
       dec   $CB6C 
       ldb   $CB6C 
       cmpb  #0x04 
       bge   P1433 
       aslb 
       bra   P1438 
P1433: ldb   #0x0C 
       subb  $CB6C 
P1438: addb  #0x02 
       andb  #0x0F 
       stb   $C844 
       stb   $C843 
       ldd   #0xE708 
       anda  $C845 
       subb  $C844 
       std   $C845 
       jmp   P14DF 
P144C: lda   #0x01 
       jsr   P14E5 
       dec   $CB6D 
       ldb   $CB6D 
       cmpb  #0x0F 
       bls   P145D 
       ldb   #0x0F 
P145D: stb   $C844 
       ldx   #0x0700 
       ldb   $C826 
       lsrb 
       ldb   $CB6D 
       bhs   P146E 
       ldx   #0x0000 
       negb 
P146E: sex 
       aslb 
       rola 
       aslb 
       rola 
       aslb 
       rola 
       aslb 
       rola 
       leax  d,x 
       stx   $C84B 
       lda   #0xFE 
       anda  $C845 
       sta   $C845 
       bra   P14DF 
P1483: lda   #0xFF 
       bsr   P14E5 
       lda   #0x01 
       sta   $CB6E 
       clr   $C877 
       lda   #0x80 
       sta   $C867 
       ldu   #ExplosionSound3 
       jsr   EXPLOD
P1498: clr   $CB6F 
       bra   P14CD 
P149D: lda   #0xFF 
       jsr   P14E5 
       lda   #0x01 
       sta   $CB6F 
       clr   $C877 
       lda   #0x80 
       sta   $C867 
       ldu   #ExplosionSound1 
       jsr   EXPLOD
       bra   P14CD 
P14B5: lda   #0xFF 
       bsr   P14E5 
       lda   #0x01 
       sta   $CB70 
       clr   $C877 
       lda   #0x80 
       sta   $C867 
       ldu   #ExplosionSound2 
       jsr   EXPLOD
P14CA: clr   $CB6F 
P14CD: jsr   EXPLOD
       lda   $C877 
       bne   P14DF 
       clr   $CB6F 
       clr   $CB70 
       clr   $CB6E 
       clr   $C867 
P14DF: puls  dp 
       jsr   REQOUT
       rts 

P14E5: tsta 
       bmi   P14FB 
       bne   P14FF 
       clr   $C856 
       clr   $CB6C 
       clr   $CB6D 
       clr   $CB6E 
       clr   $CB6F 
       clr   $CB70 
P14FB: jsr   INTREQ
       rts 
P14FF: anda  #0x07 
       tfr   a,b 
       pshs  a,b 
       asla 
       asla 
       asla 
       ora   ,s+ 
       ora   $C845 
       sta   $C845 
       ldx   #0xC83F 
       clr   ,x+ 
       clr   ,x+ 
       clr   ,x+ 
       clr   $C846 
       ldu   #0xC847 
       puls  a 
       ldb   #0x02 
P1520: lsra 
       bhs   P152D 
       clr   b,x 
       aslb 
       clr   b,u 
       incb 
       clr   b,u 
       decb 
       lsrb 
P152D: decb 
       bpl   P1520 
       rts 

ExplosionSound1:
       db    0x08 
       db    0xFF 
       db    0x00 
       db    0x02 

ExplosionSound2:
       db    0x3F 
       db    0x00 
       db    0x00 
       db    0x01 

ExplosionSound3:
       db    0x33 
       db    0x11 
       db    0x7F 
       db    0x08 

DT_IntroMusic:
       dw    DT_MusicHeader 
       dw    MSCHDR7 
       db    0x9A 
       db    0x95 
       db    0x1E 
       db    0x10 
       db    0x99 
       db    0x95 
       db    0x1E 
       db    0x05 
       db    0x99 
       db    0x95 
       db    0x1E 
       db    0x05 
       db    0x99 
       db    0x95 
       db    0x1E 
       db    0x05 
       db    0x97 
       db    0x9A 
       db    0x1E 
       db    0x10 
       db    0x95 
       db    0x9A 
       db    0x1C 
       db    0x10 
       db    0x9A 
       db    0x95 
       db    0x1E 
       db    0x10 
       db    0x9A 
       db    0x95 
       db    0x1E 
       db    0x10 
       db    0x9A 
       db    0x8E 
       db    0x21 
       db    0x18 
       db    0x99 
       db    0x90 
       db    0x1F 
       db    0x08 
       db    0x9A 
       db    0x95 
       db    0x1E 
       db    0x10 
       db    0x99 
       db    0x95 
       db    0x1E 
       db    0x05 
       db    0x99 
       db    0x95 
       db    0x1E 
       db    0x05 
       db    0x99 
       db    0x95 
       db    0x1E 
       db    0x05 
       db    0x97 
       db    0x9A 
       db    0x1E 
       db    0x10 
       db    0x95 
       db    0x9A 
       db    0x1C 
       db    0x10 
       db    0x9A 
       db    0x95 
       db    0x1E 
       db    0x10 
       db    0x9A 
       db    0x95 
       db    0x1E 
       db    0x10 
       db    0x9A 
       db    0x95 
       db    0x1E 
       db    0x08 
       db    0x9A 
       db    0x95 
       db    0x1C 
       db    0x08 
       db    0x9A 
       db    0x95 
       db    0x1A 
       db    0x08 
       db    0x9A 
       db    0x95 
       db    0x1C 
       db    0x08 
       db    0x8E 
       db    0x89 
       db    0x1E 
       db    0x7F 
       db    0x00 
       db    0x80 

DT_MusicHeader:
       db    0x0F 
       db    0xFF 
       db    0xFE 
       db    0xED 
       db    0xDC 
       db    0xCB 
       db    0xBA 
       db    0xA9 
       db    0x98 
       db    0x88 
       db    0x88 
       db    0x88 
       db    0x87 
       db    0x76 
       db    0x65 
       db    0x54 

EnteringChestSound:
       dw    MSCHDR5 
       dw    MSCHDR7 
       db    0x9C 
       db    0x90 
       db    0x04 
       db    0x0C 
       db    0x9C 
       db    0x90 
       db    0x04 
       db    0x0C 
       db    0x9C 
       db    0x90 
       db    0x04 
       db    0x06 
       db    0x9C 
       db    0x90 
       db    0x04 
       db    0x06 
       db    0x9C 
       db    0x90 
       db    0x04 
       db    0x0C 
       db    0x9F 
       db    0x93 
       db    0x07 
       db    0x0C 
       db    0x9E 
       db    0x92 
       db    0x06 
       db    0x06 
       db    0x9E 
       db    0x92 
       db    0x06 
       db    0x06 
       db    0x9C 
       db    0x90 
       db    0x04 
       db    0x06 
       db    0x9C 
       db    0x90 
       db    0x04 
       db    0x06 
       db    0x9A 
       db    0x8E 
       db    0x02 
       db    0x06 
       db    0x9C 
       db    0x90 
       db    0x04 
       db    0x0C 
       db    0x04 
       db    0x80 

FogSound:
       dw    MSCHDR6 
       dw    MSCHDR2 
       db    0x1E 
       db    0x14 
       db    0x1D 
       db    0x14 
       db    0x13 
       db    0x14 
       db    0x1D 
       db    0x14 
       db    0x1C 
       db    0x14 
       db    0x17 
       db    0x14 
       db    0x1C 
       db    0x14 
       db    0x1B 
       db    0x14 
       db    0x16 
       db    0x14 
       db    0x1B 
       db    0x14 
       db    0x1A 
       db    0x14 
       db    0x15 
       db    0x7F 
       db    0x00 
       db    0x80 

AwardSound:
       dw    DT_MusicHeader 
       dw    MSCHDR7 
       db    0xA6 
       db    0xA1 
       db    0x2A 
       db    0x10 
       db    0xA5 
       db    0xA1 
       db    0x2A 
       db    0x05 
       db    0xA5 
       db    0xA1 
       db    0x2A 
       db    0x05 
       db    0xA5 
       db    0xA1 
       db    0x2A 
       db    0x05 
       db    0xA3 
       db    0xA6 
       db    0x2A 
       db    0x10 
       db    0xA1 
       db    0xA6 
       db    0x28 
       db    0x10 
       db    0x9A 
       db    0x95 
       db    0x12 
       db    0x7F 
       db    0x00 
       db    0x80 

PlayerDeadSound:
       dw    MSCHDR6 
       dw    MSCHDR7 
       db    0x80 
       db    0x87 
       db    0x15 
       db    0x11 
       db    0x80 
       db    0x91 
       db    0x15 
       db    0x0C 
       db    0x80 
       db    0x91 
       db    0x15 
       db    0x04 
       db    0x80 
       db    0x90 
       db    0x15 
       db    0x11 
       db    0x80 
       db    0x91 
       db    0x18 
       db    0x0C 
       db    0x82 
       db    0x8E 
       db    0x17 
       db    0x04 
       db    0x84 
       db    0x8C 
       db    0x17 
       db    0x08 
       db    0x84 
       db    0x8C 
       db    0x15 
       db    0x08 
       db    0x84 
       db    0x8B 
       db    0x15 
       db    0x08 
       db    0x84 
       db    0x8B 
       db    0x14 
       db    0x08 
       db    0x84 
       db    0x8C 
       db    0x15 
       db    0x70 
       db    0x00 
       db    0x80 

; CheckForDeadPlayer()
;
; This function checks to see if the player has died, and
; if so, attempts to restart him, using one of the
; replacement warriors.  If no replacement warriors are
; left, then the game is over  else, the player restarts
; from where they last were.
 
CheckForDeadPlayer:
       lda   $C8EB 
       bne   P167D       ; Skip, if player is alive 
       lda   $C8DF      ; Any replacement warriors left? 
       ble   P167B       ; Jump if none left 
       lda   #0x01 
       sta   $C8EB      ; Flag that player is alive 
       ldx   #0xCB8C     ; Subtract one warrior from the 
       clra              ; player's reserve troops. 
       jsr   DecrementSignedString 
       dec   $C8DF      ; Decrement reserve troop counter 
       lda   #0x01 
       sta   $C8F2      ; Reset player's animation index 
       lda   #0x1F 
       sta   $C89C      ; Reset startup delay counter 
       clr   $C8F0 
       lda   #0xFF 
       sta   $C8F1      ; Set player line drawing pattern 
       rts 
P167B: inc   $C8D3      ; Flag that game is over 
P167D: rts 

; ActivateABrigand()
;
; Randomly choose one of the six brigands to activate.
; Add to the array of active brigands.  Set a random
; delay, which must expire before the brigand appears.
 
ActivateABrigand:
       lda   $C8E9 
       bpl   P1687 
       lda   $C9A0      ; Were any brigands processed in 
       bne   P16B2       ; last pass thru mainloop? 
P1687: jsr   RANDOM      ; Nope, so start one up 
       anda  #0x07       ; Randomly determine which of the 
       cmpa  #0x05       ; 6 brigands to start up. 
       bgt   ActivateABrigand  ; Bad random #; try again 
       pshs  a 
       ldb   #0x04       ; Use the randomly generated index 
       mul               ; to get a pointer to the 
       addd  #0xC9E0     ; associated brigand data. 
       tfr   d,u 
       ldb   #0x06 
       subb  ,s+ 
P169E: lda   0,u         ; Is brigand entry in use? 
       bpl   P16A9       ; Nope, so use it 
       leau  4,u         ; Yep, so try again, by checking 
       decb              ; the next available brigand; stop 
       bne   P169E       ; when we reach the end of the 
       bra   P16B2       ; brigand array. 
P16A9: lda   #0x80       ; Flag that entry is in use 
       sta   0,u 
       clr   1,u         ; Reset animation index 
       clr   $C9A1      ; Clear 'brigand hit' flag 
P16B2: jsr   RANDOM
       anda  #0x3F       ; Generate a random number, which 
       ora   #0x20       ; specifies the delay before the 
       adda  #0x1C       ; newly activated brigand starts 
       sta   $C89F      ; to appear. 
       rts 

; CheckIfAllKeysAwarded()
;
; Exit: Carry bit set if all keys have been found.
;
; This function checks to see if the player has already
; found all of the keys.
 
	direct $D0
CheckIfAllKeysAwarded:
       lda   $C8D6      ; Gold key awarded yet? 
       beq   P16D5 
       lda   $C8D7      ; Silver key awarded yet? 
       beq   P16D5 
       lda   $C8D8      ; Bronze key awarded yet? 
       beq   P16D5 
       lda   $C8D9      ; Brass key awarded yet? 
       beq   P16D5 
       orcc  #0x01       ; All keys have been awarded 
       rts 
P16D5: clra              ; Not all keys awarded yet 
       rts 

; SetLabelOfFoundObject()
;
; Entry: a = index into awards table, of the label for the
;            awarded object.
;
; This function saves the label and the drawing position
; for the object indicated by the passed-in table index.
 
	direct $C8
SetLabelOfFoundObject:
       pshs  u 
       ldu   #TableOfObjectsToFind 
       ldu   a,u 
       stu   $C8F3       ; Save ptr to string to print 
       ldu   #ObjectPositionTable 
       ldu   a,u 
       stu   $C8F5       ; Set drawing position 
       clr   $C8F7       ; Init index into H/W table 
       ldu   #AwardSound 
       jsr   SPLAY
       puls  u,pc 

; DrawEnlargingString()
;
; Displays an object found by the player.  Each pass thru,
; the string gets bigger.
 
	direct $D0
DrawEnlargingString:
       pshs  x,u 
       ldu   $C8F3      ; String to draw 
       beq   P1723       ; Skip, if ptr is NULL 
       lda   $C8F7      ; Index into H/W table 
       adda  #0x08 
       cmpa  #0x70 
       bge   P1704 
       sta   $C8F7 
P1704: ldx   #StringHeightWidthTable 
       lsra 
       lsra 
       anda  #0x1E 
       ldd   a,x 
       std   $C82A      ; Set the desired H & W values 
       jsr   INTMAX
       lda   $C8F7 
       adda  #0x04 
       sta   $D004      ; Set the scale factor 
       ldd   $C8F5      ; Set drawing position 
       jsr   POSITN
       jsr   RASTER
P1723: puls  x,u,pc 

; InvokeRandomFunctionFromTable()
;
; Enter: u = pointer to array of award functions.
;
; Exit: a = index of award, or 0 if no award.
;
; This function attempts to randomly choose an award for
; the player, from the array of possible awards passed in.
; It will attempt to award the player with something he
; can use, making a maximum of 7 attempts.  However, if
; any one attempt selects an empty entry in the array,
; then no further attempts are made.
 
	direct $C8
InvokeRandomFunctionFromTable:
       pshs  b,x,u          ; Try upto 7 times to pick an 
       lda   #0x07          ; award which the player can 
       sta   $C88B         ; use. 
P172B: jsr   RANDOM         ; Randomly select one of the 
       anda  #0x0E          ; awards. 
       ldx   a,u            ; Award nothing, if the table 
       beq   P173C          ; entry is NULL. 
       jsr   ,x             ; Attempt to give the award 
       bne   P173D          ; Jump, if we succeeded 
       dec   $C88B         ; Try again, unless we've 
       bne   P172B          ; already tried 7 times. 
P173C: clra                 ; Signal no award occurred 
P173D: puls  b,x,u,pc 

; PreserveVisibleObjectData()
;
; Anytime the player leaves the forest (i.e. entering a
; treasure chest or attempting to solve the riddle of the
; keys), we must save the current state and animation
; information for each visible object.  This function
; takes care of doing that.
 
	direct $D0
PreserveVisibleObjectData:
       pshs  x,y 
       ldx   #0xC978 
       ldy   #0xC9A6 
       lda   #0x12 
       sta   $C883      ; Set loop counter 
P174C: lda   7,y 
       sta   0,x         ; Save state machine index 
       lda   8,y 
       sta   1,x         ; Save animation index 
       leax  2,x         ; Point to next array entry 
       leay  9,y         ; Point to next array entry 
       dec   $C883      ; Decrement loop counter 
       bne   P174C       ; Process next entry 
       puls  x,y,pc 
	direct $C8

; RestoreVisibleObjectData()
;
; Anytime the player returns to the forest (i.e. leaving a
; treasure chest), we must restore the current state and 
; animation information for each visible object.  This 
; function takes care of doing that.
 
RestoreVisibleObjectData:
       pshs  x,y 
       ldx   #0xC978 
       ldy   #0xC9A6 
       lda   #0x12 
       sta   $C883      ; Set loop counter 
P176B: lda   0,x 
       sta   7,y         ; Restore state machine index 
       lda   1,x 
       sta   8,y         ; Restore animation index 
       leax  2,x         ; Point to next array entry 
       leay  9,y         ; Point to next array entry 
       dec   $C883      ; Decrement loop counter 
       bne   P176B       ; Process next entry 
       puls  x,y,pc 

; Entry: y = ptr to forest info, based on direction of travel
; 
; Exit: b = 'image flip' control bit setting.
;       a = type of tree at specified location.
 
GenerateForestData:
       ldd   ,y++ 
       lbeq  P17EE       ; Jump, if at end of data array 
       adda  $C883      ; Add modified player y position 
       sta   $C885 
       clr   $C889 
       asla 
       blo   P17EA       ; Branch if 'carry' bit set 
       asla 
       blo   P17EA       ; Branch if 'carry' bit set 
       asla 
       rol   $C889 
       addb  $C884      ; Add modified player x position 
       stb   $C886 
       aslb 
       blo   P17EA       ; Branch if 'carry' bit set 
       aslb 
       blo   P17EA       ; Branch if 'carry' bit set 
       aslb 
       rol   $C889 
       ldx   #0x1E72 
       clr   $C88A 
       ldb   $C885 
       lsrb 
       rol   $C88A 
       stb   $C88C 
       lda   #0x40 
       mul 
       std   $C887 
       ldb   $C886 
       andb  #0x3F 
       sex 
       addd  $C887 
       std   $C887 
       clr   $C88B 
       lsra 
       rorb 
       rol   $C88A 
       lsra 
       rorb 
       rol   $C88B 
       leax  d,x 
       lda   ,x 
       inca 
       beq   GenerateForestData  ; Branch if value = 0xFF 
       inca 
       beq   P17F1       ; Branch if value = 0xFE 
       ldb   $C88A 
       bne   P17DF 
       lda   ,x 
       ldb   $C88B 
       beq   P17DB 
       lsra 
       lsra 
       lsra 
       lsra 
P17DB: anda  #0x0F 
       bne   P17E1 
P17DF: lda   $C889 
P17E1: ldb   $C88B 
       eorb  $C88C 
       andb  #0x01       ; Set 'image flip' return value 
       andcc #0xFC       ; Clear 'carry' & 'overflow'  bits 
       rts 
P17EA: clra              ; Tree type = dead tree 
       orcc  #0x02       ; Set the 'overflow' bit 
       rts 
P17EE: orcc  #0x01       ; All done; set the 'carry' bit 
       rts 
P17F1: ldb   $C88A 
       bne   GenerateForestData 
       ldb   $C88B 
       bitb  #0x01 
       lbeq  GenerateForestData 
       lda   #0x07       ; Object is the Dark Tower 
       bra   P17E1 

; CheckIfObjectConsumed
; 
; Entry: y = ptr to entry in 'visible forest' array
;	       (C9A6-CA47) entry, which represents some
;	       non-tree object.
;
; Exit: $C883 = ptr to 'consumed' byte for this object.
;       $C885 = bitmask for object's 'consumed' flag.
;       a = 0 if object not consumed, else non-zero.
;
; Checks to see if a consumable object (i.e. bags of gold)
; has already been picked up by the user.
 
CheckIfObjectConsumed:
       ldb   2,y 
       andb  #0x3E 
       lda   #0x20 
       mul 
       std   $C883 
       ldb   4,y 
       andb  #0x3F 
       sex 
       addd  $C883 
       clr   $C885 
       lsra 
       rorb 
       lsra 
       rorb 
       ror   $C885 
       lsra 
       rorb 
       ror   $C885 
       lsra 
       rorb 
       ror   $C885 
       rol   $C885 
       rol   $C885 
       rol   $C885 
       rol   $C885 
       addd  #0xC8F8 
       std   $C883 
       lda   $C885       ; Convert bit number (0-7) into 
       jsr   DECBIT       ; bit mask 
       sta   $C885       ; Save the generated bitmask 
       anda  [ $C883 ] 
       rts 

; AwardNewWarrior()
;
; Award the player with a random number (1-4) of reserve
; warriors, unless he has already maxed out.
 
AwardNewWarrior:
       pshs  x 
       jsr   RANDOM
       anda  #0x03        ; Randomly determine how many 
       adda  #0x01        ; new warriors to award (1-4) 
       sta   $C883 
       lda   $C8DF       ; Increment # of reserve warriors 
       adda  $C883       ; the player has, unless he is 
       blo   P1872        ; max'ed out. 
       sta   $C8DF 
       ldx   #NewWarriorLabel 
       ldu   #0xCB5D 
       jsr   CopyStringToBuffer 
       lda   $C883       ; Create string telling player 
       ora   #0x30        ; how many warriors were awarded 
       sta   $CB5D 
       ldx   #0xCB8C      ; Ptr to 'Reserve Troops' buffer 
       lda   $C883       ; # of new troops awarded 
       jsr   UpdateAwardsStringBuffer 
       ldx   #0xCB3A      ; Update player's score, by  
       lda   $C883       ; adding (newWarriorCount ; 100) 
       clrb 
       jsr   SCRADD
       lda   #0x12        ; Flag that award occurred 
       puls  x,pc 
P1872: clra               ; Flag that no award occurred 
       puls  x,pc 

; AwardBagsOfGold()
;
; Award the player a random number (2-9) of bags of gold,
; unless already maxed out.
 
AwardBagsOfGold:
       pshs  x 
       jsr   RANDOM
       anda  #0x07        ; Generate a random number (2-9) 
       adda  #0x02        ; representing the number of 
       sta   $C884       ; bags of gold to award. 
       clr   $C883       ; Make into 16-bit number 
       ldd   $C8DD       ; Add to player's gold bag count, 
       addd  $C883       ; unless already max'ed out. 
       blo   P1872 
       std   $C8DD       ; Save updated gold count 
       ldx   #BagsOfGoldLabel 
       ldu   #0xCB5D 
       jsr   CopyStringToBuffer 
       lda   $C884       ; Insert the number of bags into 
       ora   #0x30        ; the string buffer. 
       sta   $CB5D 
       ldx   #0xCB4B      ; Ptr to 'Bags of gold' buffer 
       lda   $C884       ; # of bags awarded 
       jsr   UpdateAwardsStringBuffer 
       ldx   #0xCB3A      ; Update player's score, by 
       lda   $C884       ; adding (# bags gold ; 100) 
       clrb 
       jsr   SCRADD
       lda   #0x10 
       puls  x,pc 

; AwardGoldKey()
;
; Award the player the gold key.
 
AwardGoldKey:
       pshs  x 
       lda   $C8D6       ; Only do this once; skip if 
       bne   P1872        ; already done. 
       lda   #0x01 
       sta   $C8D6       ; Flag that Gold key was found 
       ldx   #0xCB3A 
       ldd   #0x1000      ; Add 1000 to player's score 
       jsr   SCRADD
       lda   #0x02        ; Show that bonus was awarded 
       puls  x,pc 

; AwardSilverKey()
;
; Award the player the silver key.
 
AwardSilverKey:
       pshs  x 
       lda   $C8D7       ; Only do this once; skip if 
       bne   P1872        ; already done. 
       lda   #0x01 
       sta   $C8D7       ; Flag that Silver key was found 
       ldx   #0xCB3A 
       ldd   #0x0900      ; Add 900 to player's score 
       jsr   SCRADD
       lda   #0x04        ; Show that bonus was awarded 
       puls  x,pc 

; AwardBronzeKey()
;
; Award the player the bronze key.
 
AwardBronzeKey:
       pshs  x 
       lda   $C8D8       ; Only do this once; skip if 
       bne   NoAward      ; already done. 
       lda   #0x01 
       sta   $C8D8       ; Flag that Bronze key was found 
       ldx   #0xCB3A 
       ldd   #0x0800      ; Add 800 to player's score 
       jsr   SCRADD
       lda   #0x06        ; Show that bonus was awarded 
       puls  x,pc 

; AwardBrassKey()
;
; Award the player the brass key.
 
AwardBrassKey:
       pshs  x 
       lda   $C8D9       ; Only do this once; skip if 
       bne   NoAward      ; already done. 
       lda   #0x01 
       sta   $C8D9       ; Flag that Brass key was found 
       ldx   #0xCB3A 
       ldd   #0x0700      ; Add 700 to player's score 
       jsr   SCRADD
       lda   #0x08        ; Show that bonus was awarded 
       puls  x,pc 

; AwardCrystalCrown()
;
; Award the player the crystal crown.
 
AwardCrystalCrown:
       pshs  x 
       lda   $C8DA       ; Only do this once; skip if 
       bne   NoAward      ; already done. 
       lda   #0x01 
       sta   $C8DA       ; Flag that Crystal Crown found 
       ldx   #0xCB3A 
       ldd   #0x1500      ; Add 1500 to player's score 
       jsr   SCRADD
       lda   #0x0A        ; Show that bonus was awarded 
       puls  x,pc 

; NoAward()
;
; Since what was going to be awarded the player is alread
; in the player's possession, no award will occur.
 
NoAward:
       clra               ; Show that no bonus was awarded 
       puls  x,pc 

; TryToFireNewFlamoid()
;
; Entry: x = initial 16-bit x position
;        y = initial 16-bit y position
;        a = angle
;        b =
;
; If the flamoid buffer is not full, then fire another
; flamoid.
 
TryToFireNewFlamoid:
       pshs  a,b,x,y 
       ldu   #0xC9F8      ; Ptr to flamoid array 
       ldb   #0x08        ; # of entries in the array 
P192C: lda   0,u          ; If this entry is not active, 
       beq   FireNewFlamoid   ; go ahead and use it. 
       leau  11,u         ; Else, try next entry. 
       decb 
       bne   P192C 
       orcc  #0x01        ; Signal that the flamoid array 
       puls  a,b,x,y,pc   ; was full; couldn't do new one. 

; FireNewFlamoid()
;
; Add a new flamoid to the list of active flamoids.
 
FireNewFlamoid:
       lda   #0x01 
       sta   0,u          ; Mark entry as active 
       lda   #0x90 
       sta   10,u         ; Set lifespan counter 
       ldd   2,s 
       std   7,u          ; Set initial x position 
       ldd   4,s 
       std   5,u          ; Set initial y position 
       lda   1,s 
       sta   9,u 
       lda   #0x40 
       ldb   ,s           ; Get firing angle 
       jsr   LNROT
       sta   $C883       ; Calculate 16-bit x delta 
       sex 
       aslb 
       rola 
       aslb 
       rola 
       aslb 
       rola 
       std   3,u          ; Set 16-bit x delta 
       ldb   $C883       ; Calculate 16-bit y delta 
       sex 
       aslb 
       rola 
       aslb 
       rola 
       aslb 
       rola 
       std   1,u          ; Set 16-bit y delta 
       lda   #0x80 
       sta   $CB6E 
       clra               ; Flag that flamoid was fired 
       puls  a,b,x,y,pc 

; RegisterNewExplosionEntry()
;
; Entry: a = Scale factor
;        u = Vector list pointer
;        x = 16-bit x position
;        y = 16-bit y position
;
; If the explosion buffer is not full, then add a new
; explosion to the list of active explosions.
 
RegisterNewExplosionEntry:
       pshs  a,x,y,u 
       ldu   #0xCA50      ; Ptr to explosion buffer array 
       ldb   #0x0E        ; Loop counter 
P1979: lda   0,u          ; Look for an unused entry 
       beq   FillExplosionEntry 
       leau  15,u         ; Try next entry 
       decb 
       bne   P1979 
       orcc  #0x01        ; Flag no open entry found 
       puls  a,x,y,u,pc 

; FillExplosionEntry()
;
; Entry: u = ptr to explosion buffer entry to be filled
;        a = Scale factor
;        u = Vector list pointer
;        x = 16-bit x position
;        y = 16-bit y position
;
; Fill in the indicated explosion buffer entry, with
; details about the new explosion.
 
FillExplosionEntry:
       lda   #0x01 
       sta   0,u          ; Flag entry as in use 
       sty   5,u          ; Save initial y position 
       stx   7,u          ; Save initial x position 
       clr   10,u         ; Set initial angle = 0 
       jsr   CONE
       sta   11,u         ; Save spin rate 
       lda   #0x30 
       sta   14,u         ; Set lifespan counter 
       lda   ,s 
       sta   9,u          ; Save scale factor 
       ldd   5,s 
       std   12,u         ; Save vector list ptr 
       jsr   CONE
       lda   #0x20        ; Set velocity 
       jsr   MLTY16
       sty   1,u          ; Save 16-bit rise value 
       stx   3,u          ; Save 16-bit run value 
       clra               ; Flag that open entry was found 
       puls  a,x,y,u,pc 

; UpdatePosition()
;
; Entry: u = Ptr to flamoid or explosion buffer entry
;
; Exit: Sets 'Carry' bit if 'y' value overflowed.
;	  Sets 'Overflow' bit if 'x' value overflowed.
;
; Update the (y,x) information for this entry, using the
; rise and run information contained in the entry.
 
UpdatePosition:
       ldd   5,u          ; Load 16-bit y position 
       addd  1,u          ; Add 16-bit y delta 
       pshs  a 
       tfr   ccr,a        ; Check for y overflow 
       anda  #0x02 
       lsra 
       sta   -1,s         ; Save overflow flag 
       puls  a 
       std   5,u          ; Save updated 16-bit y position 
       ldd   7,u          ; Load 16-bit x position 
       addd  3,u          ; Add 16-bit x delta 
       pshs  a 
       tfr   ccr,a        ; Check for x overflow 
       anda  #0xF2 
       ora   -1,s 
       sta   -1,s         ; Update overflow flags 
       puls  a 
       std   7,u          ; Save updated 16-bit x position 
       lda   -2,s 
       tfr   a,ccr        ; Set condition codes to saved 
       rts                ; value. 

; TryToStartFog()
;
; If a fog is not already active, start one, and make
; the appropriate sound.
 
TryToStartFog:
       pshs  dp,x,y,u 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       lda   $C9A0 
       bne   P19F9        ; Skip, if a fog is active 
       lda   #0x01 
       sta   $C9A0       ; Set 'increase fog' mode 
       clr   $C9A1       ; Init fog loop counter 
       ldd   #0x0500 
       std   $C9A4       ; Reset plague delay counter 
       ldu   #FogSound 
       jsr   SPLAY
P19F9: puls  dp,x,y,u,pc 

; TryToStartPlague()
;
; If a fog is not already active, start one, and make
; the appropriate sound.
 
TryToStartPlague:
       pshs  dp,x,y,u 
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       lda   $C9A2        ; Only start plague if not 
       ora   $C9A4        ; already active, and if plague 
       ora   $C9A5        ; delay counter has reached 0. 
       bne   P1A20         ; Skip if plague already active 
       lda   #0x01 
       sta   $C9A2        ; Signal plague is starting 
       ldu   #PlayerDeadSound 
       jsr   SPLAY
       clr   $C9A3        ; Clear plague duration counter 
       ldd   #0x0500 
       std   $C9A4        ; Reset plague delay counter 
P1A20: puls  dp,x,y,u,pc 

; ClearAllGameStorageArrays()
;
; This function clears out all of the 'area' specific
; game memory.  This is necessary anythime the player
; leaves a particular area (i.e. the forest, or a chest).
 
ClearAllGameStorageArrays:
       ldx   #0xC9A0       ; Clear C9A0-CB2B 
P1A25: clr   ,x+ 
       cmpx  #0xCB2C 
       bne   P1A25 
       clr   $CB6C 
       clr   $CB6D 
       clr   $CB6E 
       clr   $CB6F 
       clr   $CB70 
       rts 

; UpdateAwardsStringBuffer()
;
; Entry: x = ptr to string buffer
;        a = # of objects be awarded
 
UpdateAwardsStringBuffer:
       pshs  a,x 
       leax  1,x 
       lda   2,x       ; If this position is a space char, 
       ora   #0x10     ; then convert it to an ascii '0' 
       adda  ,s        ; Add in the # of awarded objects 
       sta   2,x       ; Store back into the string 
       cmpa  #0x39     ; Check for digit overflow 
       ble   P1AA3     ; No overflow occurred, so jump 
       suba  #0x0A     ; Subtract 10 from this digit 
       sta   2,x 
       ldb   #0x01     ; Jump elsewhere, to take care of 
       bra   P1A60     ; carry, and stripping leading 0's 

; IncrementSignedString()
; DecrementSignedString()
;
; Entry: a = 0 => string value is not at 0
;            1 => string value is currently at 0
;        x = pointer to signed string buffer
;
; Exit:  a = 0 => string value is not at 0
;            1 => string value is now at 0
;
; This code triggers off of the leading character in the
; string, to determine if the current value is negative
; (if so, then the leading character will be '-').  After 
; updating the string value, any leading zeros will be
; stripped off, and the string will be reset to " 0", if
; necessary.
 
IncrementSignedString:
       pshs  a,x 
       lda   ,x        ; Skip elsewhere, if the first digit 
       cmpa  #0x2D     ; is "-" (negative number). 
       beq   P1A86 
P1A5C: leax  1,x       ; Process the least significant 
       ldb   #0x02     ; digit first. 
P1A60: lda   b,x       ; Add 1 to digit; if its a " ", 
       ora   #0x10     ; then or with 0x10, to first 
       inca            ; convert it to a '0' . 
       sta   b,x       ; Save updated digit. 
       cmpa  #0x39     ; Check for digit wrapping past '9' 
       bls   P1AA3 
       lda   #0x30     ; Wrap occurred; convert this digit 
       sta   b,x       ; to '0', and increment the next 
       decb            ; digit. 
       bpl   P1A60 
       bra   P1AA3     ; All done 

DecrementSignedString:
       pshs  a,x 
       lda   ,x        ; If first digit is '-' (negative 
       cmpa  #0x2D     ; number), then jump elsewhere. 
       beq   P1A5C 
       lda   ,s        ; If the # of steps is currently 
       beq   P1A86     ; '0', then we need to force the 
       lda   #0x2D     ; step count to be negative, by 
       sta   ,x        ; adding a '-' to the front. 
       bra   P1A5C 
P1A86: leax  1,x       ; Process least significant digit 
       ldb   #0x02     ; first. 
       lda   b,x 
       cmpa  #0x30     ; If the digit is '0', then we will 
       bgt   P1AA1     ; need to force a 'borrow' operation 
P1A90: lda   #0x39     ; Need to do a borrow
       sta   b,x       ; Force this digit to '9' first 
       decb            ; Point to the next digit 
       bmi   P1AA3 
       dec   b,x       ; Perform the borrow 
       lda   b,x 
       cmpa  #0x30     ; See if this forces us to then 
       bge   P1AA3     ; need to borrow from the next 
       bra   P1A90     ; digit. 
P1AA1: dec   b,x       ; Decrement digit, then all done 

; Strip off leading zeros 
P1AA3: clrb            ; Reset index into steps string 
       clr   ,s        ; Set return value 
P1AA6: lda   b,x 
       bmi   P1AB5     ; Did we reach end of string? 
       cmpa  #0x30     ; Strip off leading '0's, by 
       bgt   P1AC2     ; replacing them with ' ' characters 
       lda   #0x20 
       sta   b,x 
       incb            ; Process next digit 
       bra   P1AA6 

; All digits were stripped, so reset string to " 0" 
P1AB5: lda   #0x30 
       decb 
       sta   b,x       ; Set last digit to '0' 
       lda   #0x20 
       sta   -1,x      ; Set next to last digit to ' ' 
       lda   #0x01 
       sta   ,s        ; Set return value 
P1AC2: puls  a,x,pc 

; CheckForGameOver()
;
; If the player has run out of lives, then display the
; "Game Over' string, along with the score.  Set a timer
; for automatically restarting a new game, and check for
; Btn 4, to see if a new game should be started immediately.
 
	direct $D0
CheckForGameOver:
       lda   $C8D3   ; Has player run out of lives? 
       beq   P1B09    ; Nope 

DisplayGameOverInfo:
       pshs  dp 
       jsr   INTMAX
       ldu   #GameOverLabel  ; Display 'Game Over' 
       jsr   PrintMultiPartString 
       ldd   #0x78DC     ; Move the pen 
       jsr   POSITD
       ldd   #0xF638 
       std   $C82A      ; Set string H & W values 
       ldu   #0xCB39     ; Display player's score 
       jsr   RASTER
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       ldx   #0xCB3A     ; Did player set new hi score? 
       ldu   #0xCBEB 
       jsr   HISCR
       clr   $C89C      ; Clear startup delay counter 
       clr   $C89F      ; Disable C8A0 invocation 
       clr   $C8A2      ; Disable C8A3 invocation 
       clr   $C8A5 
       ldx   $C8D4      ; Decrement restart timer; 
       beq   P1B0A       ; restart new game when = 0. 
       leax  -1,x 
       stx   $C8D4 
       lda   $C815      ; Start new game if btn 4 on 
       bne   P1B0A       ; console 1 is pressed. 
       puls  dp 
P1B09: rts 
P1B0A: leas  3,s         ; Fix the stack, then restart 
       jmp   StartNewGame 

; SetPlayersPositionInForest()
;
; Set the player's screen position to the location (y,x)
; (0xC0,0x00), and reset other attributes.
 
SetPlayersPositionInForest:
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       ldd   #0xC000 
       std   $C8EC      ; Set player's 16-bit y position 
       ldd   #0x0000 
       std   $C8EE      ; Set player's 16-bit x position 
       clr   $C8F0 
       lda   #0xFF 
       sta   $C8F1      ; Set player line drawing pattern 
       lda   #0x01 
       sta   $C8F2      ; Reset player's animation index 
       clr   $C8BF      ; Flag that player's in the forest 
       clr   $C8C0 
       rts 

; SetPlayersPositionInChest()
;
; Set the player's screen position to the location (y,x)
; (0x28,0x00), and reset other attributes.
 
SetPlayersPositionInChest:
       lda   #0xC8 
       tfr   a,dp 
	direct $C8
       ldd   #0x2800 
       std   $C8EC      ; Set player's 16-bit y position 
       ldd   #0x0000 
       std   $C8EE      ; Set player's 16-bit x position 
       lda   #0x7F 
       sta   $C8F0 
       lda   #0xFF 
       sta   $C8F1      ; Set player line drawing pattern 
       clr   $C8F2      ; Reset player's animation index 
       clr   $C8C0 
       lda   #0x01 
       sta   $C8BF      ; Flag that player's in a chest 
       lda   #0x88 
       sta   $C8CB 
       rts 

; PlacePlayerRandomlyInForest()
;
; This function generates a new random forest location
; and angle of travel for the player.  It also updates
; the visible forest information.
 
PlacePlayerRandomlyInForest:
       jsr   RANDOM
       anda  #0x3F       ; Set random direction, in range 
       sta   $C8B2      ; 0-359 degrees. 
       bsr   PlayerChangedDirection 
       bsr   SetPlayersPositionInForest 
       jsr   RANDOM
       lsra              ; The following block generates 
       rorb              ; a 16-bit number, in the range 
       lsra              ; 0x0401-0x39FF.  The value 
       rorb              ; represents the player's new 
       cmpd  #0x3A00     ; 16-bit 'y' position, within 
       blt   P1B6A       ; the forest. 
       subd  #0x0800 
P1B6A: cmpd  #0x0400 
       bgt   P1B73 
       addd  #0x0800 
P1B73: std   $C8B4      ; Save player's new 16-bit 'y' pos 
       sta   $C8B8      ; Save pos where forest was inited 
       jsr   RANDOM
       lsra              ; The following block generates 
       rorb              ; a 16-bit number, in the range 
       lsra              ; 0x0401-0x39FF.  The value 
       rorb              ; represents the player's new 
       cmpd  #0x3A00     ; 16-bit 'x' position, within 
       blt   P1B87       ; the forest. 
       subd  #0x0800 
P1B87: cmpd  #0x0400 
       bgt   P1B90 
       addd  #0x0800 
P1B90: std   $C8B6      ; Save player's new 16-bit 'x' pos 
       sta   $C8B9      ; Save pos where forest was inited 
       clr   $C8C1 
       jmp   FillInVisibleForestInfo 

; PlayerChangedDirection()
;
; When the player turns left or right, or is randomly
; placed back into the forest, this function is called.
; It initializes some of the variables holding information
; about the angle of travel, and it also resets the step
; count (and the associated string) to '0 steps'.
 
PlayerChangedDirection:
       lda   $C8B2     ; Get player's angle of travel 
       suba  #0x08      ; The following saves the angle 
       anda  #0x3F      ; minus 45 degrees; however, C8B3 
       sta   $C8B3     ; is never referenced anywhere !! 
       lda   $C8B2     ; Force direction in the range of 
       anda  #0x3F      ; 0-359 degrees. 
       sta   $C8B2 
       adda  #0x20 
       sta   $C836     ; Use angle + 180 degrees 
       jsr   SINCOS     ; Get sin & cos 
       ldd   $C837 
       std   $C8C4     ; Save the sin value 
       ldd   $C839 
       std   $C8C6     ; Save the cos value 
       lda   #0x20      ; Get velocity 
       ldb   $C8B2     ; Get angle (direction) 
       addb  #0x20      ; Use angle + 180 degrees 
       jsr   LNROT
       sta   $C883     ; Temporarily save the rise value 
       sex              ; Convert run to 16 bits 
       std   $C8BC     ; Save 16-bit run value 
       ldb   $C883     ; Retrieve saved rise value 
       sex              ; Convert to 16 bits 
       std   $C8BA     ; Save 16-bit rise value 
       ldd   #0x2020 
       std   $CB44     ; Set CB44-CB49 = "  0",0x80 
       std   $CB46     ; This will track # of steps taken 
       ldd   #0x3080    ; since the last change in 
       std   $CB48     ; direction of travel. 
       lda   #0x01 
       sta   $CB4A     ; Force step count to 0 
       ldx   #CompassPointLabels 
       lda   $C8B2     ; Map angle of travel into a 
       lsra             ; compass direction. 
       lsra 
       anda  #0x0E 
       ldx   a,x 
       ldu   #0xCB41    ; Fill buffer with string 
P1BEB: lda   ,x+        ; indicating the direction of 
       bmi   P1BF3      ; travel. 
       sta   ,u+ 
       bra   P1BEB 
P1BF3: rts 

P1BF4: ldd   #0x0080 
       std   $C837     ; Force sin = 180 degrees 
       ldd   #0xFF81 
       std   $C839     ; Force cos = 180 degrees 
       lda   $C8EC     ; Get player's y position 
       sta   $C8CA 
       lda   $C8EE     ; Get player's x position 
       sta   $C8C8 
       lda   #0xF8 
       sta   $C8C9 
       bsr   TransformPoint 
       lda   $C8CD 
       sta   $C8D0 
       lda   $C8CE 
       sta   $C8D1 
       rts 

; TransformPoint() 
;
; Entry: C8CA = y coordinate to be rotated.
;        C8C8 = x coordinate to be rotated.
;
; Exit:
;
; This function rotates a translated point about the
; virtual origin, using the standard rotation transformation:
;
;	y = -(y*cos() - x*sin())
;	x = -(x*cos() + y*sin())
;
; Note that the above transformations both are negated  I'm
; not sure why this is, other than maybe it's due to the
; fact that these transformations assume a clockwise angle,
; and the vectrex uses a counter-clockwise angle.
 
TransformPoint:
       lda   $C8CA     ; Get y scalar value 
       jsr   MCSINE     ; y ; cos() 
       sta   $C883     ; Save the result 
       lda   $C8C8     ; Get x scalar value 
       jsr   MSINE      ; x ; sin() 
       suba  $C883     ; -((y;cos()) - (x*sin())) 
       ble   P1C4B 
       sta   $C8CC     ; Save rotated y endpoint 
       lda   $C8C9 
       bsr   P1C4E 
       bvs   P1C4B 
       cmpb  $C8CB 
       ble   P1C4B 
       stb   $C8CD 
       lda   $C8C8     ; Get x scalar value 
       jsr   MCSINE     ; x ; cos() 
       sta   $C883     ; Save the result 
       lda   $C8CA     ; Get y scalar value 
       jsr   MSINE      ; y ; sin() 
       adda  $C883     ; ((x;cos()) + (y*sin())) 
       nega             ; -((x;cos()) + (y*sin())) 
       bsr   P1C4E 
       bvs   P1C4B 
       stb   $C8CE 
       andcc #0xFD 
       rts 
P1C4B: orcc  #0x02 
       rts 

P1C4E: tfr   ccr,b 
       bpl   P1C53 
       nega 
P1C53: stb   $C884 
       clr   $C885 
       cmpa  $C8CC 
       bge   P1C87 
       ldb   $C8CC 
       subb  #0x02 
       blo   P1C87 
       cmpb  #0x0E 
       bhi   P1C67 
       dec   $C885 
P1C67: ldy   #0x2172 
       ldb   b,y 
       mul 
       tst   $C885 
       bne   P1C7A 
       asra 
       rorb 
       asra 
       rorb 
       asra 
       rorb 
       asra 
       rorb 
P1C7A: tstb 
       bmi   P1C87 
       lda   $C884 
       tfr   a,ccr 
       bpl   P1C84 
       negb 
P1C84: andcc #0xFD 
       rts 
P1C87: orcc  #0x02 
       rts 

; CopyStringToBuffer()
;
; Entry: x = string to be copied.
;        u = buffer into which string will be copied.
 
CopyStringToBuffer:
       lda   ,x+ 
       sta   ,u+ 
       bpl   CopyStringToBuffer 
       rts 

; PrintMultiPartString()
;
; Entry: u = ptr to multi-part string.
;
; Displays a multi-part (or multi-line) string.  The
; string has the following format:
;
;	h,w,y,x,string,0x80,h,w,y,x,string,0x80,0x00
 
	direct $D0
PrintMultiPartString:
       pshs  u 
P1C93: ldd   ,u++ 
       std   $C82A 
       ldd   ,u++ 
       jsr   POSITD
       jsr   RASTER
       lda   ,u 
       bne   P1C93 
       puls  u,pc 

; DrawDotsIfActive()
;
; Entry: d = (y,x) position to draw dots at
;
; The work performed by this function is controlled by
; the value of CB89, which can take on the following values:
;
;	 0 => Dot sequence is inactive.
;	>0 => Scale adjustment factor (CB8A) will be
;	      increased over time.
;	<0 => Scale adjustment factor (CB8A) will be
;	      decreased over time.
 
DrawDotsIfActive:
       std   $C885      ; Save location 
       lda   $CB89      ; Do nothing if dot sequence is 
       beq   P1CE6       ; not active. 
       bmi   P1CBE       ; Use decreasing scale adj factor 
       lda   $CB8A      ; Use increasing scale adj factor 
       adda  #0x02       ; Increase scale adjustment factor 
       sta   $CB8A      ; by 2.  We're done when it goes 
       cmpa  #0x20       ; >= 0x20. 
       bge   P1D1D       ; All done 
       bra   P1CC8       ; Keep it active 
P1CBE: lda   $CB8A      ; Use decreasing scale adj factor 
       suba  #0x02       ; Decrease scale adj factor by 2. 
       sta   $CB8A      ; We're done when it goes <= 0 
       ble   P1D1D       ; All done 
P1CC8: lda   $CB8A 
       sta   $C889      ; Set scale adjustment factor 
       lda   #0x09       ; Initialize the index used to 
       sta   $C88A      ; index into the dot list table 
P1CD3: jsr   ZERGND
       dec   $C88A      ; Decrement dot table index 
       bne   DrawDotList 
       lda   $C889      ; When the dot index goes to 0, 
       adda  #0x08       ; then update the scale and 
       sta   $C889      ; intensity adjuster value, and 
       jsr   ZERGND      ; then return. 
P1CE6: lda   $CB8A 
       asla 
       rts               ; Return (adj factor ; 2) 

; DrawDotList()
;
; Entry: C885 = (y,x) drawing position
;	  C889 = Scale/Intensity adjustment
;        C88A = Index into dot array
;
; Exit:  a = Scale adjustment factor
;
; Draws a set of dots, whose intensity and scale are
; calculated using the current index into the dot array,
; adjusted by the value in C889.
 
DrawDotList:
       lda   #0x03       ; Number of dots to draw - 1 
       sta   $C823 
       ldd   $C885      ; Load drawing position 
       suba  #0x08       ; Subtract 8 from y position 
       jsr   POSITD
       ldb   $C88A      ; Calculate scale factor 
       aslb              ; Multiply index by 4 
       aslb 
       addb  $C889      ; Factor in scale adjustment 
       ble   P1CD3       ; Skip if scale <= 0 
       andb  #0x7F       ; Force scale in range 0 - 0x7F 
       stb   $D004      ; Set scale factor 
       ldx   #0xCB71     ; Get ptr to array of dot lists 
       lda   $C88A      ; Get the dot table index, and 
       deca              ; use it to generate the offset 
       asla              ; into the dot list table. 
       ldx   a,x         ; Get next dot list from array 
       lda   #0x7F       ; Calculate the intensity 
       suba  $C889      ; Factor in intensity adjustment 
       jsr   INTENS
       jsr   DIFDOT
       bra   P1CD3 
P1D1D: jsr   ZERGND
       clr   $CB89      ; Flag dot sequence is complete 
       lda   $CB8A 
       asla 
       rts               ; Return (adj factor ; 2) 

; Draw2VectorLists()
;
; Entry: y = addr of drawing position
;        x = vector list 2
;        d = vector list 1
;        C8AB - C8AC = intensity & scale
;        C8AD = alternate vector list 1
;        C8AF = alternate vector list 2
;
; If 'd' is not 0x0000, then the two primary vector lists
; are drawn  otherwise, the alternate vector lists are
; drawn.  In either case, before drawing, the pen is moved
; to the position specified by the 2 8-bit values pointed
; to by the 'y' register.
 
Draw2VectorLists:
       pshs  a,b,dp,x,y 
       lda   #0xD0 
       tfr   a,dp 
	direct $D0
       ldd   $C8AB      ; Get intensity & scale values 
       ldy   5,s         ; Get addr of drawing position 
       ldx   0,s         ; Get vector list 
       beq   P1D46 
       bsr   DT_MoveThenDraw 
       ldd   $C8AB      ; Get intensity & scale values 
       ldx   3,s         ; Get vector list 
       ldy   5,s         ; Get addr of drawing position 
       bsr   DT_MoveThenDraw 
       puls  a,b,dp,x,y,pc 
P1D46: ldx   $C8AD      ; Get vector list 
       bsr   DT_MoveThenDraw 
       ldd   $C8AB      ; Get intensity & scale values 
       ldx   $C8AF      ; Get vector list 
       ldy   5,s         ; Get addr of drawing position 
       bsr   DT_MoveThenDraw 
       puls  a,b,dp,x,y,pc 

; Draw2VectorLists_16bit()
;
; Entry: y = addr of 16-bit drawing position
;        x = vector list 2
;        d = vector list 1
;        C8AB - C8AC = intensity & scale
;        C8AD = alternate vector list 1
;        C8AF = alternate vector list 2
;
; If 'd' is not 0x0000, then the two primary vector lists
; are drawn  otherwise, the alternate vector lists are
; drawn.  In either case, before drawing, the pen is moved
; to the position specified by the 2 16-bit values pointed
; to by the 'y' register.
 
Draw2VectorLists_16bit:
       pshs  a,b,dp,x,y 
       lda   #0xD0 
       tfr   a,dp 
	direct $D0
       ldd   $C8AB      ; Get intensity & scale values 
       ldy   5,s         ; Get drawing position 
       ldx   0,s         ; Get vector list 
       beq   P1D76 
       bsr   DT_16bitMoveThenDraw 
       ldd   $C8AB      ; Get intensity & scale values 
       ldx   3,s         ; Get vector list 
       ldy   5,s         ; Get drawing position 
       bsr   DT_16bitMoveThenDraw 
       puls  a,b,dp,x,y,pc 
P1D76: ldx   $C8AD      ; Get vector list 
       bsr   DT_16bitMoveThenDraw 
       ldd   $C8AB      ; Get intensity & scale values 
       ldx   $C8AF      ; Get vector list 
       ldy   5,s         ; Get drawing position 
       bsr   DT_16bitMoveThenDraw 
       puls  a,b,dp,x,y,pc 

; DT_MoveThenDraw()
;
; Entry: a = intensity
;        b = scale
;        y = ptr to 8-bit (y,x) position to move to
;        x = ptr to mode and vector list, where mode is:
;
;           0  => <0 or 0xFF> y x
;           <0 => (count-1) y x y x ...  (move to 1st point)
;           >0 => (count-1) y x y x ...  (draw to 1st point)
;
 
DT_MoveThenDraw:
       pshs  b,x,y 
       jsr   INTENS
       ldd   ,y 
       jsr   POSITD
       puls  b,x,y 
       bra   DT_Draw 

; DT_16bitMoveThenDraw()
;
; Entry: a = intensity
;        b = scale
;        y = ptr to 16-bit (yHiyLo,xHixLo) position to move to
;        x = ptr to mode and vector list, where mode is:
;
;           0  => <0 or 0xFF> y x
;           <0 => (count-1) y x y x ...  (move to 1st point)
;           >0 => (count-1) y x y x ...  (draw to 1st point)
;
 
DT_16bitMoveThenDraw:
       pshs  b,x,y 
       jsr   INTENS
       tfr   y,x 
       jsr   POSWID
       puls  b,x,y 

; DT_Draw()
;
; Entry: b = scale
;        x = ptr to mode and vector list, where mode is:
;
;           0  => <0 or 0xFF> y x
;           <0 => (count-1) y x y x ...  (move to 1st point)
;           >0 => (count-1) y x y x ...  (draw to 1st point)
;
; CBA0 is used to control whether the 'x' coordinate is
; negated before drawing is done  this will 'flip' the
; image.  Useful when drawing something walking, since
; you only need to store the images for 1 side moving 
; to get the other side to move, you simply flip the image.
 
DT_Draw:
       stb   $D004       ; Set scale factor 
       lda   ,x+ 
       beq   P1E21 
       bmi   P1DB0 
       bra   P1DDD 
P1DAC: stb   $D004 
       lda   ,x+ 

P1DB0: anda  #0x3F        ; Move to first point in list 
       sta   $C823       ; Save number of points 
       ldd   ,x           ; Load y,x pair 
       sta   $D001       ; Write y value 
       clr   $D000 
       leax  2,x 
       nop 
       inc   $D000 
       tst   $CBA0       ; Flip the image? 
       beq   P1DC6 
       negb 
P1DC6: stb   $D001       ; Write x value 
       ldd   #0x0000 
       sta   $D00A       ; Force line pattern to 0 
       stb   $D005 
       ldd   #0x0040 
P1DD2: bitb  $D00D       ; Wait for timer interrupt 
       beq   P1DD2 
       nop 
       sta   $D00A 
       lda   $C823 
P1DDC: deca               ; Decrement point counter 

P1DDD: sta   $C823       ; Save number of points 
       ldd   ,x           ; Load next y,x pair 
       sta   $D001       ; Write y value 
       clr   $D000 
       leax  2,x 
       nop 
       inc   $D000 
       tst   $CBA0       ; Flip the image? 
       beq   P1DF1 
       negb 
P1DF1: stb   $D001       ; Write x value 
       lda   $C829 
       ldb   #0x40 
       sta   $D00A       ; Set line pattern 
       clr   $D005 
       bitb  $D00D       ; Timer interrupt happened yet? 
       beq   P1E0D 
       clr   $D00A       ; Yes; clear line pattern 
       lda   $C823 
       bne   P1DDC        ; Anymore points to draw? 
       jmp   ZERGND       ; Nope; all done 
P1E0A: lda   $C829 
P1E0D: sta   $D00A       ; Set line pattern again 
       nop 
       bitb  $D00D       ; Timer interrupt happened yet? 
       beq   P1E0A 
       lda   $C823       ; Yes 
       clr   $D00A 
       tsta               ; Anymore points to draw? 
       bne   P1DDC 
       jmp   ZERGND       ; Nope; all done 

; These vector lists have 3 bytes per entry 
P1E1F: stb   $D004       ; Set scale factor 
P1E21: ldd   1,x          ; Load next y,x pair 
       sta   $D001       ; Write y value 
       clr   $D000 
       lda   ,x           ; Get line pattern 
       leax  3,x 
       tst   $CBA0       ; Flip the image? 
       beq   P1E31 
       negb 
P1E31: inc   $D000 
       stb   $D001       ; Write x value 
       sta   $D00A       ; Set line pattern 
       clr   $D005 
       ldd   #0x0040 
P1E3C: bitb  $D00D       ; Wait for timer interrupt 
       beq   P1E3C 
       nop 
       sta   $D00A       ; Clear drawing pattern 
       lda   ,x 
       ble   P1E21        ; Anymore points to draw? 
       jmp   ZERGND       ; Nope; all done. 

; This space appears to be unused 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 

S1E72: db    0x00 
       db    0xFF 
       db    0xFF 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x61 
       db    0x06 
       db    0xFF 
       db    0xFF 
       db    0x00 
       db    0xFF 
       db    0x00 
       db    0x00 
       db    0xE0 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x15 
       db    0x19 
       db    0x11 
       db    0xFF 
       db    0xFF 
       db    0xFF 
       db    0x08 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x18 
       db    0x11 
       db    0x1A 
       db    0x11 
       db    0x1B 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x00 
       db    0xE0 
       db    0x0D 
       db    0x00 
       db    0xC0 
       db    0x00 
       db    0x0B 
       db    0x00 
       db    0x11 
       db    0x61 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x61 
       db    0x11 
       db    0x11 
       db    0x00 
       db    0x00 
       db    0x60 
       db    0x05 
       db    0x00 
       db    0x0E 
       db    0x00 
       db    0x00 
       db    0x19 
       db    0x18 
       db    0x1A 
       db    0x11 
       db    0x18 
       db    0x11 
       db    0x1B 
       db    0x11 
       db    0x00 
       db    0x00 
       db    0x09 
       db    0x00 
       db    0x08 
       db    0x00 
       db    0x0A 
       db    0x00 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x61 
       db    0x11 
       db    0x11 
       db    0x60 
       db    0x00 
       db    0x00 
       db    0x06 
       db    0x00 
       db    0x60 
       db    0x00 
       db    0xE0 
       db    0x1F 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x1B 
       db    0x11 
       db    0x00 
       db    0x00 
       db    0x0B 
       db    0x00 
       db    0x0C 
       db    0x00 
       db    0x0D 
       db    0x00 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x61 
       db    0x11 
       db    0x1A 
       db    0x16 
       db    0x11 
       db    0x00 
       db    0x00 
       db    0x60 
       db    0x0E 
       db    0x00 
       db    0x60 
       db    0x00 
       db    0x00 
       db    0x18 
       db    0x11 
       db    0x1A 
       db    0x11 
       db    0x1A 
       db    0x11 
       db    0x19 
       db    0x11 
       db    0x00 
       db    0xE0 
       db    0x0B 
       db    0x00 
       db    0x0A 
       db    0x00 
       db    0x08 
       db    0x00 
       db    0x11 
       db    0x61 
       db    0x11 
       db    0x18 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x0E 
       db    0x1A 
       db    0x11 
       db    0x1B 
       db    0x11 
       db    0x18 
       db    0x11 
       db    0x1F 
       db    0x11 
       db    0x06 
       db    0x00 
       db    0x00 
       db    0x06 
       db    0x00 
       db    0x0E 
       db    0x00 
       db    0x00 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x00 
       db    0xB0 
       db    0x00 
       db    0xA0 
       db    0x44 
       db    0x44 
       db    0x44 
       db    0x44 
       db    0x46 
       db    0x44 
       db    0x44 
       db    0x48 
       db    0x1A 
       db    0x11 
       db    0x1B 
       db    0x11 
       db    0x00 
       db    0x08 
       db    0x00 
       db    0x00 
       db    0x44 
       db    0x84 
       db    0x46 
       db    0x44 
       db    0x44 
       db    0x44 
       db    0x4B 
       db    0x44 
       db    0x11 
       db    0x16 
       db    0x11 
       db    0x11 
       db    0x00 
       db    0xA0 
       db    0x00 
       db    0xB0 
       db    0x44 
       db    0x44 
       db    0xFF 
       db    0xFF 
       db    0x44 
       db    0x4F 
       db    0x44 
       db    0x44 
       db    0x18 
       db    0x11 
       db    0x19 
       db    0x11 
       db    0x00 
       db    0x00 
       db    0x08 
       db    0x00 
       db    0x4E 
       db    0xFF 
       db    0xFF 
       db    0xFF 
       db    0xFF 
       db    0xFF 
       db    0x44 
       db    0xE4 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x11 
       db    0x62 
       db    0x22 
       db    0x62 
       db    0x22 
       db    0x44 
       db    0xFF 
       db    0xFF 
       db    0xFE 
       db    0xFF 
       db    0xFF 
       db    0x44 
       db    0x44 
       db    0x33 
       db    0x63 
       db    0x33 
       db    0x63 
       db    0x22 
       db    0x92 
       db    0x22 
       db    0xA2 
       db    0x44 
       db    0xFF 
       db    0xFF 
       db    0xFF 
       db    0xFF 
       db    0xFF 
       db    0x44 
       db    0x44 
       db    0x3A 
       db    0x33 
       db    0x3A 
       db    0x33 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x44 
       db    0x94 
       db    0xFF 
       db    0xFF 
       db    0x44 
       db    0x4F 
       db    0x4B 
       db    0x44 
       db    0x33 
       db    0x38 
       db    0x33 
       db    0x33 
       db    0x2A 
       db    0x22 
       db    0x2A 
       db    0x22 
       db    0x44 
       db    0x44 
       db    0x44 
       db    0x44 
       db    0x44 
       db    0x44 
       db    0x44 
       db    0x44 
       db    0x3B 
       db    0x33 
       db    0x3A 
       db    0x33 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x62 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x62 
       db    0x33 
       db    0x36 
       db    0x33 
       db    0x33 
       db    0x36 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x28 
       db    0x22 
       db    0x28 
       db    0x22 
       db    0x2A 
       db    0x22 
       db    0x2B 
       db    0x22 
       db    0x3C 
       db    0x33 
       db    0x3D 
       db    0x33 
       db    0x3E 
       db    0x33 
       db    0x3F 
       db    0x33 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x28 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x63 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x2F 
       db    0x22 
       db    0x2E 
       db    0x22 
       db    0x2D 
       db    0x26 
       db    0x2C 
       db    0x22 
       db    0x3B 
       db    0x33 
       db    0x3A 
       db    0x33 
       db    0x39 
       db    0x33 
       db    0x38 
       db    0x33 
       db    0x22 
       db    0x26 
       db    0x22 
       db    0x28 
       db    0x62 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x36 
       db    0x2A 
       db    0x22 
       db    0xA2 
       db    0x22 
       db    0x2B 
       db    0x22 
       db    0x2A 
       db    0x22 
       db    0x38 
       db    0x33 
       db    0x38 
       db    0x36 
       db    0x3A 
       db    0x33 
       db    0x3A 
       db    0x33 
       db    0x22 
       db    0x26 
       db    0x22 
       db    0x26 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x33 
       db    0x38 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x2B 
       db    0x22 
       db    0x2B 
       db    0x22 
       db    0x2A 
       db    0x22 
       db    0x2A 
       db    0x22 
       db    0x3A 
       db    0x33 
       db    0x39 
       db    0x33 
       db    0x38 
       db    0x33 
       db    0x3A 
       db    0x33 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x36 
       db    0x33 
       db    0x33 
       db    0x36 
       db    0x33 
       db    0xFF 
       db    0xFF 
       db    0xFF 
       db    0x22 
       db    0x2B 
       db    0x22 
       db    0x2C 
       db    0x22 
       db    0x3D 
       db    0x33 
       db    0x3E 
       db    0x33 
       db    0x3F 
       db    0x33 
       db    0x38 
       db    0x33 
       db    0xFF 
       db    0xFF 
       db    0xFF 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x35 
       db    0x33 
       db    0x36 
       db    0x25 
       db    0xFF 
       db    0xFF 
       db    0x26 
       db    0x22 
       db    0x62 
       db    0x22 
       db    0x29 
       db    0x33 
       db    0x63 
       db    0x33 
       db    0x36 
       db    0x33 
       db    0x33 
       db    0x33 
       db    0x36 

; The entry used from this array is determined by the
; player's direction of travel.
 
DirectionalForestData:
       dw    NorthForestData      ; Direction = North 
       dw    NorthWestForestData  ; Direction = NorthWest 
       dw    WestForestData       ; Direction = West 
       dw    SouthWestForestData  ; Direction = SouthWest 
       dw    SouthForestData      ; Direction = South 
       dw    SouthEastForestData  ; Direction = SouthEast 
       dw    EastForestData       ; Direction = East 
       dw    NorthEastForestData  ; Direction = NorthEast 

NorthForestData:
       db    0x05 
       db    0x06 
       db    0x05 
       db    0x07 
       db    0x05 
       db    0x08 
       db    0x05 
       db    0x09 
       db    0x04 
       db    0x05 
       db    0x04 
       db    0x06 
       db    0x04 
       db    0x07 
       db    0x04 
       db    0x08 
       db    0x04 
       db    0x09 
       db    0x03 
       db    0x05 
       db    0x03 
       db    0x06 
       db    0x03 
       db    0x07 
       db    0x03 
       db    0x08 
       db    0x03 
       db    0x09 
       db    0x00 
       db    0x00 

NorthWestForestData:
       db    0x03 
       db    0x07 
       db    0x03 
       db    0x08 
       db    0x03 
       db    0x09 
       db    0x04 
       db    0x07 
       db    0x04 
       db    0x08 
       db    0x04 
       db    0x09 
       db    0x05 
       db    0x07 
       db    0x05 
       db    0x08 
       db    0x05 
       db    0x09 
       db    0x06 
       db    0x07 
       db    0x06 
       db    0x08 
       db    0x06 
       db    0x09 
       db    0x07 
       db    0x08 
       db    0x07 
       db    0x09 
       db    0x08 
       db    0x09 
       db    0x00 
       db    0x00 

WestForestData:
       db    0x05 
       db    0x09 
       db    0x06 
       db    0x07 
       db    0x06 
       db    0x08 
       db    0x06 
       db    0x09 
       db    0x07 
       db    0x07 
       db    0x07 
       db    0x08 
       db    0x07 
       db    0x09 
       db    0x08 
       db    0x07 
       db    0x08 
       db    0x08 
       db    0x08 
       db    0x09 
       db    0x09 
       db    0x08 
       db    0x09 
       db    0x09 
       db    0x00 
       db    0x00 

SouthWestForestData:
       db    0x07 
       db    0x06 
       db    0x07 
       db    0x07 
       db    0x07 
       db    0x08 
       db    0x07 
       db    0x09 
       db    0x08 
       db    0x06 
       db    0x08 
       db    0x07 
       db    0x08 
       db    0x08 
       db    0x08 
       db    0x09 
       db    0x09 
       db    0x06 
       db    0x09 
       db    0x07 
       db    0x09 
       db    0x08 
       db    0x09 
       db    0x09 
       db    0x00 
       db    0x00 

SouthForestData:
       db    0x07 
       db    0x03 
       db    0x07 
       db    0x04 
       db    0x07 
       db    0x05 
       db    0x07 
       db    0x06 
       db    0x07 
       db    0x07 
       db    0x08 
       db    0x03 
       db    0x08 
       db    0x04 
       db    0x08 
       db    0x05 
       db    0x08 
       db    0x06 
       db    0x08 
       db    0x07 
       db    0x09 
       db    0x03 
       db    0x09 
       db    0x04 
       db    0x09 
       db    0x05 
       db    0x09 
       db    0x06 
       db    0x09 
       db    0x07 
       db    0x00 
       db    0x00 

SouthEastForestData:
       db    0x05 
       db    0x03 
       db    0x05 
       db    0x04 
       db    0x06 
       db    0x03 
       db    0x06 
       db    0x04 
       db    0x06 
       db    0x05 
       db    0x07 
       db    0x03 
       db    0x07 
       db    0x04 
       db    0x07 
       db    0x05 
       db    0x08 
       db    0x03 
       db    0x08 
       db    0x04 
       db    0x08 
       db    0x05 
       db    0x09 
       db    0x03 
       db    0x09 
       db    0x04 
       db    0x09 
       db    0x05 
       db    0x00 
       db    0x00 

EastForestData:
       db    0x03 
       db    0x03 
       db    0x03 
       db    0x04 
       db    0x03 
       db    0x05 
       db    0x04 
       db    0x03 
       db    0x04 
       db    0x04 
       db    0x04 
       db    0x05 
       db    0x05 
       db    0x03 
       db    0x05 
       db    0x04 
       db    0x05 
       db    0x05 
       db    0x06 
       db    0x03 
       db    0x06 
       db    0x04 
       db    0x06 
       db    0x05 
       db    0x07 
       db    0x03 
       db    0x07 
       db    0x04 
       db    0x07 
       db    0x05 
       db    0x00 
       db    0x00 

NorthEastForestData:
       db    0x03 
       db    0x03 
       db    0x03 
       db    0x04 
       db    0x03 
       db    0x05 
       db    0x03 
       db    0x06 
       db    0x03 
       db    0x07 
       db    0x04 
       db    0x03 
       db    0x04 
       db    0x04 
       db    0x04 
       db    0x05 
       db    0x04 
       db    0x06 
       db    0x04 
       db    0x07 
       db    0x05 
       db    0x03 
       db    0x05 
       db    0x04 
       db    0x05 
       db    0x05 
       db    0x05 
       db    0x06 
       db    0x05 
       db    0x07 
       db    0x00 
       db    0x00 

S2172: db    0x80 
       db    0x55 
       db    0x40 
       db    0x33 
       db    0x2C 
       db    0x25 
       db    0x20 
       db    0x1C 
       db    0x1A 
       db    0x17 
       db    0x15 
       db    0x14 
       db    0x12 
       db    0x11 
       db    0x10 
       db    0xF1 
       db    0xE4 
       db    0xD8 
       db    0xCD 
       db    0xC3 
       db    0xBA 
       db    0xB2 
       db    0xAB 
       db    0xA4 
       db    0x9E 
       db    0x98 
       db    0x92 
       db    0x8D 
       db    0x89 
       db    0x84 
       db    0x80 
       db    0x7C 
       db    0x78 
       db    0x75 
       db    0x72 
       db    0x6F 
       db    0x6C 
       db    0x69 
       db    0x66 
       db    0x64 
       db    0x62 
       db    0x5F 
       db    0x5D 
       db    0x5B 
       db    0x59 
       db    0x57 
       db    0x55 
       db    0x54 
       db    0x52 
       db    0x50 
       db    0x4F 
       db    0x4D 
       db    0x4C 
       db    0x4A 
       db    0x49 
       db    0x48 
       db    0x47 
       db    0x45 
       db    0x44 
       db    0x43 
       db    0x42 
       db    0x41 
       db    0x40 
       db    0x3F 
       db    0x3E 
       db    0x3D 
       db    0x3C 
       db    0x3B 
       db    0x3B 
       db    0x3A 
       db    0x39 
       db    0x38 
       db    0x37 
       db    0x37 
       db    0x36 
       db    0x35 
       db    0x35 
       db    0x34 
       db    0x33 
       db    0x33 
       db    0x32 
       db    0x31 
       db    0x31 
       db    0x30 
       db    0x30 
       db    0x2F 
       db    0x2F 
       db    0x2E 
       db    0x2E 
       db    0x2D 
       db    0x2D 
       db    0x2C 
       db    0x2C 
       db    0x2B 
       db    0x2B 
       db    0x2A 
       db    0x2A 
       db    0x29 
       db    0x29 
       db    0x29 
       db    0x28 
       db    0x28 
       db    0x27 
       db    0x27 
       db    0x27 
       db    0x26 
       db    0x26 
       db    0x26 
       db    0x25 
       db    0x25 
       db    0x25 
       db    0x24 
       db    0x24 
       db    0x24 
       db    0x23 
       db    0x23 
       db    0x23 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x22 
       db    0x21 
       db    0x21 
       db    0x21 
       db    0x21 
       db    0x20 

; Animation table 
TreasureChestBase_Table:
       dw    TreasureChestBaseClosed 
       dw    TreasureChestBaseOpen 
       dw    TreasureChestBaseOpen 
       dw    TreasureChestBaseOpen 
       dw    TreasureChestBaseOpen 
       dw    TreasureChestBaseOpen 
       dw    0x0000 

; Animation table 
TreasureChestLid_Table:
       dw    TreasureChestLidClosed 
       dw    TreasureChestLidOpening_1 
       dw    TreasureChestLidOpening_2 
       dw    TreasureChestLidOpening_3 
       dw    TreasureChestLidOpening_4 
       dw    TreasureChestLidOpening_5 

; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
TreasureChestBaseClosed:
       db    0x07 
       db    0xE8 
       db    0x00 
       db    0xF8 
       db    0xE0 
       db    0x18 
       db    0x00 
       db    0x00 
       db    0xC0 
       db    0xE8 
       db    0x00 
       db    0x00 
       db    0x40 
       db    0x18 
       db    0x00 
       db    0x08 
       db    0x20 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
TreasureChestLidClosed:
       db    0x0A 
       db    0x08 
       db    0x00 
       db    0x00 
       db    0xC0 
       db    0xF8 
       db    0xE0 
       db    0x00 
       db    0x40 
       db    0xF8 
       db    0x00 
       db    0x08 
       db    0x1F 
       db    0x07 
       db    0x00 
       db    0xF8 
       db    0xE0 
       db    0xF8 
       db    0x00 
       db    0x00 
       db    0xC1 
       db    0x08 
       db    0x00 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
TreasureChestBaseOpen:
       db    0x09 
       db    0xE8 
       db    0x00 
       db    0xF8 
       db    0xE0 
       db    0x18 
       db    0x00 
       db    0x00 
       db    0xC0 
       db    0xE8 
       db    0x00 
       db    0x00 
       db    0x40 
       db    0x18 
       db    0x00 
       db    0x08 
       db    0x20 
       db    0x00 
       db    0xC0 
       db    0xF8 
       db    0xE0 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
TreasureChestLidOpening_1:
       db    0x0B 
       db    0x09 
       db    0x02 
       db    0x08 
       db    0xE0 
       db    0xF7 
       db    0xFE 
       db    0x00 
       db    0xC0 
       db    0xF8 
       db    0x20 
       db    0x07 
       db    0x02 
       db    0xF9 
       db    0xFE 
       db    0x00 
       db    0x40 
       db    0x07 
       db    0xE0 
       db    0x09 
       db    0x02 
       db    0x00 
       db    0xC0 
       db    0xF7 
       db    0xFE 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
TreasureChestLidOpening_2:
       db    0x0E 
       db    0x09 
       db    0x04 
       db    0x10 
       db    0xE0 
       db    0xF8 
       db    0xFC 
       db    0x00 
       db    0xC0 
       db    0x07 
       db    0x04 
       db    0x00 
       db    0x40 
       db    0xF8 
       db    0xFC 
       db    0xF0 
       db    0x21 
       db    0x00 
       db    0xC0 
       db    0x10 
       db    0xDF 
       db    0x00 
       db    0x12 
       db    0xF8 
       db    0x12 
       db    0xF8 
       db    0xFD 
       db    0x08 
       db    0x03 
       db    0x00 
       db    0x29 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
TreasureChestLidOpening_3:
       db    0x0D 
       db    0x06 
       db    0x06 
       db    0x1A 
       db    0xE4 
       db    0xFA 
       db    0xFA 
       db    0x00 
       db    0xC0 
       db    0x06 
       db    0x06 
       db    0x00 
       db    0x40 
       db    0xFA 
       db    0xFA 
       db    0xE6 
       db    0x1C 
       db    0x07 
       db    0xF8 
       db    0x00 
       db    0xCF 
       db    0x12 
       db    0xEA 
       db    0x00 
       db    0xF4 
       db    0xE7 
       db    0x1C 
       db    0x06 
       db    0x06 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
TreasureChestLidOpening_4:
       db    0x0E 
       db    0x02 
       db    0x08 
       db    0x24 
       db    0xF6 
       db    0xFE 
       db    0xF8 
       db    0x00 
       db    0xC0 
       db    0x02 
       db    0x08 
       db    0x00 
       db    0x40 
       db    0xFE 
       db    0xF8 
       db    0xDC 
       db    0x0A 
       db    0x03 
       db    0xFF 
       db    0x00 
       db    0xCA 
       db    0xFE 
       db    0xF8 
       db    0x02 
       db    0x08 
       db    0x22 
       db    0xF5 
       db    0xFE 
       db    0xF8 
       db    0xDD 
       db    0x0B 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
TreasureChestLidOpening_5:
       db    0x0B 
       db    0xFE 
       db    0x08 
       db    0x24 
       db    0x08 
       db    0x02 
       db    0xF8 
       db    0x00 
       db    0xC0 
       db    0xDD 
       db    0xF8 
       db    0x00 
       db    0x08 
       db    0x20 
       db    0x08 
       db    0x02 
       db    0xF8 
       db    0xFE 
       db    0x08 
       db    0x00 
       db    0x38 
       db    0x02 
       db    0x00 
       db    0xDC 
       db    0xF7 

; Animation table 
PlayerWalking_RightSide_Table:
       dw    PlayerStandingStillRightSide 
       dw    PlayerWalkingRightSide2 
       dw    PlayerWalkingRightSide3 
       dw    PlayerWalkingRightSide2 
       dw    PlayerWalkingRightSide3 
       dw    0x0000 

; Animation table 
PlayerWalking_LeftSide_Table:
       dw    PlayerStandingStillLeftSide 
       dw    PlayerWalkingLeftSide2 
       dw    PlayerWalkingLeftSide3 
       dw    PlayerWalkingLeftSide2 
       dw    PlayerWalkingLeftSide3 

; Table controlling whether the image is flipped or not.
;
;	0x00 => don't flip
;	0xFF => flip
 
PlayerWalkingImageControlTable:
       db    0x00 
       db    0x00 
       db    0x00 
       db    0xFF 
       db    0xFF 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PlayerStandingStillRightSide:
       db    0x14 
       db    0x14 
       db    0xFF 
       db    0x00 
       db    0x02 
       db    0xE6 
       db    0x00 
       db    0x02 
       db    0x05 
       db    0xF8 
       db    0x01 
       db    0xFE 
       db    0x0C 
       db    0xD4 
       db    0xFE 
       db    0xFE 
       db    0xFC 
       db    0x06 
       db    0x02 
       db    0xFE 
       db    0xFC 
       db    0x02 
       db    0x00 
       db    0x04 
       db    0x04 
       db    0x1E 
       db    0xFC 
       db    0xF4 
       db    0xFC 
       db    0xF0 
       db    0x04 
       db    0xD0 
       db    0xFE 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0x04 
       db    0xF8 
       db    0xFC 
       db    0x00 
       db    0xFC 
       db    0x32 
       db    0xFA 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PlayerStandingStillLeftSide:
       db    0x1A 
       db    0x14 
       db    0x01 
       db    0x00 
       db    0xFE 
       db    0xE6 
       db    0x00 
       db    0x04 
       db    0xF5 
       db    0x0C 
       db    0x00 
       db    0x08 
       db    0x0C 
       db    0xF8 
       db    0x0C 
       db    0xF4 
       db    0x00 
       db    0xFB 
       db    0xF4 
       db    0x02 
       db    0xFA 
       db    0xF8 
       db    0xFE 
       db    0xFE 
       db    0xF4 
       db    0xD4 
       db    0x02 
       db    0xFE 
       db    0x04 
       db    0x06 
       db    0xFE 
       db    0xFE 
       db    0x04 
       db    0x02 
       db    0x00 
       db    0x04 
       db    0xFC 
       db    0x1E 
       db    0x04 
       db    0xF4 
       db    0x04 
       db    0xF0 
       db    0xFC 
       db    0xD0 
       db    0x02 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0xFC 
       db    0xF8 
       db    0x04 
       db    0x00 
       db    0x04 
       db    0x33 
       db    0x05 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PlayerWalkingRightSide2:
       db    0x1A 
       db    0x14 
       db    0xFF 
       db    0x00 
       db    0x02 
       db    0xE6 
       db    0x00 
       db    0x02 
       db    0x05 
       db    0xF8 
       db    0x01 
       db    0xFE 
       db    0x0C 
       db    0xD4 
       db    0xFE 
       db    0xFE 
       db    0xFC 
       db    0x06 
       db    0x02 
       db    0xFE 
       db    0xFC 
       db    0x02 
       db    0x00 
       db    0x04 
       db    0x04 
       db    0x1E 
       db    0xFC 
       db    0xF4 
       db    0xFC 
       db    0xDC 
       db    0x08 
       db    0xF4 
       db    0xFA 
       db    0x02 
       db    0xFE 
       db    0x00 
       db    0xFE 
       db    0xFE 
       db    0xFE 
       db    0xF6 
       db    0x02 
       db    0x00 
       db    0x06 
       db    0x0A 
       db    0xFE 
       db    0x02 
       db    0xFE 
       db    0x00 
       db    0xFE 
       db    0xFE 
       db    0xFE 
       db    0x0C 
       db    0x04 
       db    0x0F 
       db    0xF9 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PlayerWalkingLeftSide2:
       db    0x1C 
       db    0x14 
       db    0x01 
       db    0x00 
       db    0xFE 
       db    0xE6 
       db    0x00 
       db    0x04 
       db    0xF5 
       db    0x0C 
       db    0x00 
       db    0x08 
       db    0x0C 
       db    0xF8 
       db    0x0C 
       db    0xF4 
       db    0x00 
       db    0xFB 
       db    0xF4 
       db    0x02 
       db    0xFA 
       db    0xF8 
       db    0xFE 
       db    0xFC 
       db    0xF4 
       db    0xE6 
       db    0x00 
       db    0xF6 
       db    0x04 
       db    0xF8 
       db    0x02 
       db    0x06 
       db    0x00 
       db    0xFE 
       db    0x02 
       db    0x02 
       db    0x00 
       db    0x02 
       db    0xFE 
       db    0x0C 
       db    0xFE 
       db    0x14 
       db    0x04 
       db    0xF4 
       db    0x04 
       db    0xF0 
       db    0xFC 
       db    0xD0 
       db    0x02 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0xFC 
       db    0xF8 
       db    0x04 
       db    0x00 
       db    0x04 
       db    0x32 
       db    0x05 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PlayerWalkingRightSide3:
       db    0x17 
       db    0x14 
       db    0xFF 
       db    0x00 
       db    0x02 
       db    0xE6 
       db    0x00 
       db    0x02 
       db    0x05 
       db    0xF8 
       db    0x01 
       db    0xFE 
       db    0x0C 
       db    0xD4 
       db    0xFE 
       db    0xFE 
       db    0xFC 
       db    0x06 
       db    0x02 
       db    0xFE 
       db    0xFC 
       db    0x02 
       db    0x00 
       db    0x04 
       db    0x04 
       db    0x1E 
       db    0xFC 
       db    0xF4 
       db    0xFC 
       db    0xF0 
       db    0x04 
       db    0xEC 
       db    0x00 
       db    0xF2 
       db    0xFE 
       db    0x02 
       db    0x00 
       db    0x02 
       db    0x06 
       db    0xFC 
       db    0x00 
       db    0xFC 
       db    0xFA 
       db    0x00 
       db    0xFC 
       db    0x14 
       db    0x00 
       db    0x0E 
       db    0xFA 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PlayerWalkingLeftSide3:
       db    0x18 
       db    0x14 
       db    0x01 
       db    0x00 
       db    0xFE 
       db    0xE6 
       db    0x00 
       db    0x04 
       db    0xF5 
       db    0x0C 
       db    0x00 
       db    0x08 
       db    0x0C 
       db    0xF8 
       db    0x0C 
       db    0xF4 
       db    0x00 
       db    0xFB 
       db    0xF4 
       db    0x02 
       db    0xFA 
       db    0xF8 
       db    0xFE 
       db    0xFC 
       db    0xF4 
       db    0xE4 
       db    0x02 
       db    0x02 
       db    0x08 
       db    0x03 
       db    0x01 
       db    0x00 
       db    0xFC 
       db    0x12 
       db    0x01 
       db    0xF4 
       db    0x04 
       db    0xF0 
       db    0xFC 
       db    0xD0 
       db    0x02 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0xFC 
       db    0xF8 
       db    0x04 
       db    0x00 
       db    0x04 
       db    0x33 
       db    0x05 

; Vector list:
;
;	0 => each point has its own drawing mode flag
;	list of (mode,y,x) triplets, where mode is:
;
;	0x00 => move to next point
;	0xFF => draw to next point
;     0x01 => end of list
 
BrigandWalls:
       db    0x00 
       db    0x00 
       db    0x38 
       db    0xC4 
       db    0xFF 
       db    0x00 
       db    0x10 
       db    0xFF 
       db    0xA0 
       db    0x00 
       db    0xFF 
       db    0x00 
       db    0xF0 
       db    0x00 
       db    0x08 
       db    0x10 
       db    0xFF 
       db    0x00 
       db    0x0C 
       db    0xFF 
       db    0x50 
       db    0x00 
       db    0xFF 
       db    0x00 
       db    0xF4 
       db    0x00 
       db    0xFA 
       db    0x0C 
       db    0xFF 
       db    0x00 
       db    0x08 
       db    0xFF 
       db    0xBC 
       db    0x00 
       db    0xFF 
       db    0x00 
       db    0xF8 
       db    0x00 
       db    0x04 
       db    0x08 
       db    0xFF 
       db    0x00 
       db    0x06 
       db    0xFF 
       db    0x3A 
       db    0x00 
       db    0xFF 
       db    0x00 
       db    0xFA 
       db    0x01 

; Animation table 
PlyrSideStepping_RightSide_Tbl:
       dw    PlayerStandingStillRightSide 
       dw    PlayerWalkingRightSide3 
       dw    PlayerWalkingRightSide3 
       dw    0x0000 

; Animation table 
PlyrSideStepping_LeftSide_Tbl:
       dw    PlayerStandingStillLeftSide 
       dw    PlayerWalkingLeftSide3 
       dw    PlayerWalkingLeftSide3 

; When the player is side-stepping, this table controls
; when the image is flipped during drawing.
ImageFlip_Table:
       db    0x00 
       db    0x00 
       db    0xFF 

; Animation table 
PlayerThrowing_RightSide_Table:
       dw    PlayerStandingStillRightSide 
       dw    PlayerThrowing_RightSide1 
       dw    PlayerThrowing_RightSide2 
       dw    PlayerThrowing_RightSide3 
       dw    PlayerThrowing_RightSide2 
       dw    PlayerThrowing_RightSide4 
       dw    PlayerThrowing_RightSide5 
       dw    PlayerThrowing_RightSide5 
       dw    PlayerThrowing_RightSide5 
       dw    PlayerThrowing_RightSide5 
       dw    PlayerThrowing_RightSide6 
       dw    0x0000 

; The player's animation index is used to index into this
; table.  If the value is '1', then the player is ready
; to thrown the flamoid.
 
PlayerFireSynchronization:
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x01 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PlayerThrowing_RightSide1:
       db    0x18 
       db    0x14 
       db    0xFF 
       db    0x00 
       db    0x02 
       db    0xE6 
       db    0x00 
       db    0x02 
       db    0x05 
       db    0xF8 
       db    0x01 
       db    0xFE 
       db    0x0C 
       db    0xEE 
       db    0x08 
       db    0xFA 
       db    0x05 
       db    0x00 
       db    0x04 
       db    0xFE 
       db    0x01 
       db    0x00 
       db    0xFD 
       db    0xFC 
       db    0x04 
       db    0xFC 
       db    0x00 
       db    0x00 
       db    0xFA 
       db    0x06 
       db    0xFE 
       db    0x08 
       db    0xF4 
       db    0x0D 
       db    0xFA 
       db    0xF4 
       db    0xFC 
       db    0xF0 
       db    0x04 
       db    0xD0 
       db    0xFE 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0x04 
       db    0xF8 
       db    0xFC 
       db    0x00 
       db    0xFC 
       db    0x32 
       db    0xFA 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PlayerThrowing_RightSide3:
       db    0x18 
       db    0x14 
       db    0xFF 
       db    0x00 
       db    0x02 
       db    0xE6 
       db    0x00 
       db    0x02 
       db    0x05 
       db    0xF8 
       db    0x01 
       db    0xFC 
       db    0x0C 
       db    0x06 
       db    0xFE 
       db    0xFC 
       db    0xFC 
       db    0x02 
       db    0xFF 
       db    0x04 
       db    0x02 
       db    0x02 
       db    0xFA 
       db    0x06 
       db    0x02 
       db    0x00 
       db    0x06 
       db    0xFE 
       db    0x04 
       db    0xF0 
       db    0x06 
       db    0xFA 
       db    0x00 
       db    0x04 
       db    0xF2 
       db    0xF4 
       db    0xFC 
       db    0xF0 
       db    0x04 
       db    0xD0 
       db    0xFE 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0x04 
       db    0xF8 
       db    0xFC 
       db    0x00 
       db    0xFC 
       db    0x32 
       db    0xFA 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PlayerThrowing_RightSide2:
       db    0x18 
       db    0x14 
       db    0xFF 
       db    0x00 
       db    0x02 
       db    0xE6 
       db    0x00 
       db    0x02 
       db    0x05 
       db    0xF8 
       db    0x01 
       db    0xFE 
       db    0x08 
       db    0xFC 
       db    0x08 
       db    0x0A 
       db    0x08 
       db    0x02 
       db    0xFE 
       db    0x02 
       db    0x02 
       db    0xFF 
       db    0x01 
       db    0x03 
       db    0x01 
       db    0xFE 
       db    0x04 
       db    0xFC 
       db    0x00 
       db    0xFE 
       db    0xFC 
       db    0xF0 
       db    0xFC 
       db    0x04 
       db    0xF0 
       db    0xF6 
       db    0xFA 
       db    0xF0 
       db    0x04 
       db    0xD0 
       db    0xFE 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0x04 
       db    0xF8 
       db    0xFC 
       db    0x00 
       db    0xFC 
       db    0x32 
       db    0xFA 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PlayerThrowing_RightSide4:
       db    0x17 
       db    0x14 
       db    0xFF 
       db    0x00 
       db    0x02 
       db    0xE6 
       db    0x00 
       db    0x02 
       db    0x05 
       db    0xF8 
       db    0x01 
       db    0xFE 
       db    0x08 
       db    0xFA 
       db    0x06 
       db    0x04 
       db    0x0A 
       db    0x02 
       db    0x01 
       db    0x00 
       db    0x01 
       db    0xFF 
       db    0x00 
       db    0x03 
       db    0x03 
       db    0xFC 
       db    0x00 
       db    0xFE 
       db    0xFC 
       db    0xF8 
       db    0xF8 
       db    0x02 
       db    0xF4 
       db    0xF8 
       db    0xFB 
       db    0xF0 
       db    0x04 
       db    0xD0 
       db    0xFE 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0x04 
       db    0xF8 
       db    0xFC 
       db    0x00 
       db    0xFC 
       db    0x32 
       db    0xFA 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PlayerThrowing_RightSide5:
       db    0x15 
       db    0x14 
       db    0xFF 
       db    0x00 
       db    0x02 
       db    0xE6 
       db    0x00 
       db    0x02 
       db    0x05 
       db    0xF8 
       db    0x01 
       db    0x00 
       db    0x06 
       db    0xFE 
       db    0x04 
       db    0x02 
       db    0x04 
       db    0x02 
       db    0xFE 
       db    0x00 
       db    0x01 
       db    0x04 
       db    0xFF 
       db    0xFE 
       db    0x04 
       db    0xF8 
       db    0x00 
       db    0xFA 
       db    0xF2 
       db    0xF6 
       db    0xFF 
       db    0xF0 
       db    0x04 
       db    0xD0 
       db    0xFE 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0x04 
       db    0xF8 
       db    0xFC 
       db    0x00 
       db    0xFC 
       db    0x32 
       db    0xFA 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PlayerThrowing_RightSide6:
       db    0x17 
       db    0x14 
       db    0xFF 
       db    0x00 
       db    0x02 
       db    0xE6 
       db    0x00 
       db    0x02 
       db    0x05 
       db    0xF8 
       db    0x01 
       db    0xFE 
       db    0x0C 
       db    0xEC 
       db    0x04 
       db    0xF8 
       db    0xFE 
       db    0xFA 
       db    0x00 
       db    0xFE 
       db    0xFC 
       db    0x06 
       db    0xFE 
       db    0xFE 
       db    0xFE 
       db    0x01 
       db    0xFF 
       db    0x03 
       db    0x03 
       db    0x08 
       db    0x02 
       db    0x0E 
       db    0xFB 
       db    0xF4 
       db    0xFC 
       db    0xF0 
       db    0x04 
       db    0xD0 
       db    0xFE 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0x04 
       db    0xF8 
       db    0xFC 
       db    0x00 
       db    0xFC 
       db    0x32 
       db    0xFA 


; Vector list:
;
;	((count - 1) | 0x80) => Move to first point
;	list of (y,x) pairs.
 
PlayerExploding_Head:
       db    0x8F 
       db    0x18 
       db    0x00 
       db    0x14 
       db    0x01 
       db    0x00 
       db    0xFE 
       db    0xE6 
       db    0x00 
       db    0x04 
       db    0xF5 
       db    0x0C 
       db    0x00 
       db    0x08 
       db    0x0C 
       db    0xF8 
       db    0x0C 
       db    0xF4 
       db    0x00 
       db    0xFB 
       db    0xF4 
       db    0x02 
       db    0xFA 
       db    0xF8 
       db    0xFE 
       db    0x08 
       db    0x02 
       db    0xFE 
       db    0x06 
       db    0x02 
       db    0x06 
       db    0xF8 
       db    0x02 


; Vector list:
;
;	((count - 1) | 0x80) => Move to first point
;	list of (y,x) pairs.
 
PlayerExploding_LeftArm:
       db    0x89 
       db    0x0C 
       db    0xF8 
       db    0xFE 
       db    0xF4 
       db    0xD4 
       db    0x02 
       db    0xFE 
       db    0x04 
       db    0x06 
       db    0xFE 
       db    0xFE 
       db    0x04 
       db    0x02 
       db    0x00 
       db    0x04 
       db    0xFC 
       db    0x1E 
       db    0x04 
       db    0xF4 
       db    0x04 


; Vector list:
;
;	((count - 1) | 0x80) => Move to first point
;	list of (y,x) pairs.
 
PlayerExploding_RightArm:
       db    0x8D 
       db    0x0C 
       db    0x08 
       db    0xFE 
       db    0x08 
       db    0xFC 
       db    0x08 
       db    0x0A 
       db    0x08 
       db    0x02 
       db    0xFE 
       db    0x02 
       db    0x02 
       db    0xFF 
       db    0x01 
       db    0x03 
       db    0x01 
       db    0xFE 
       db    0x04 
       db    0xFC 
       db    0x00 
       db    0xFE 
       db    0xFC 
       db    0xF0 
       db    0xFC 
       db    0x04 
       db    0xF0 
       db    0xF6 
       db    0xFA 


; Vector list:
;
;	((count - 1) | 0x80) => Move to first point
;	list of (y,x) pairs.
 
PlayerExploding_Body:
       db    0x8E 
       db    0xF8 
       db    0xFA 
       db    0xF0 
       db    0xFC 
       db    0xD0 
       db    0x02 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0xFC 
       db    0xF8 
       db    0x04 
       db    0x00 
       db    0x04 
       db    0x33 
       db    0x05 
       db    0xCD 
       db    0x05 
       db    0x00 
       db    0x04 
       db    0x08 
       db    0x04 
       db    0x02 
       db    0xFC 
       db    0xFC 
       db    0x00 
       db    0x30 
       db    0x02 
       db    0x10 
       db    0xFC 

; Animation table 
BrigandArmAndBodyTable:
       dw    0xFFFF 
       dw    BrigandArmAndBody_1 
       dw    BrigandArmAndBody_1 
       dw    BrigandArmAndBody_2 
       dw    BrigandArmAndBody_2 
       dw    BrigandArmAndBody_2 
       dw    BrigandArmAndBody_1 
       dw    BrigandArmAndBody_1 
       dw    BrigandArmAndBody_2 
       dw    BrigandArmAndBody_3 
       dw    BrigandArmAndBody_3 
       dw    BrigandArmAndBody_3 
       dw    BrigandArmAndBody_3 
       dw    BrigandArmAndBody_3 
       dw    BrigandArmAndBody_3 
       dw    BrigandArmAndBody_3 
       dw    BrigandArmAndBody_4 
       dw    BrigandArmAndBody_5 
       dw    BrigandArmAndBody_6 
       dw    BrigandArmAndBody_6 
       dw    BrigandArmAndBody_5 
       dw    0x0000 

; Animation table 
BrigandHeadTable:
       dw    0xFFFF 
       dw    0xFFFF 
       dw    0xFFFF 
       dw    BrigandHead_1 
       dw    BrigandHead_1 
       dw    BrigandHead_1 
       dw    0xFFFF 
       dw    0xFFFF 
       dw    BrigandHead_1 
       dw    BrigandHead_2 
       dw    BrigandHead_2 
       dw    BrigandHead_2 
       dw    BrigandHead_2 
       dw    BrigandHead_2 
       dw    BrigandHead_2 
       dw    BrigandHead_2 
       dw    BrigandHead_2 
       dw    BrigandHead_2 
       dw    BrigandHead_2 
       dw    BrigandHead_2 
       dw    0xFFFF 

; As the brigand is animating, there reaches a point where
; it it time to throw a flamoid.  The animation index is
; used to index into this table  when a non-zero value is
; obtained, a flamoid will be thrown.
 
FlamoidControlTable:
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x01 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 

; The brigand is only vulnerable to a hit from the player's
; flamoid when he (the brigand) is fully exposed.  The
; table below indicates at what point during the animation
; the brigand is exposed.  The brigand's animation index
; is used to index into this array.  If the array value
; is '1', then the brigand is vulnerable.
 
BrigandIsVulnerable:
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x00 
       db    0x01 
       db    0x01 
       db    0x01 
       db    0x01 
       db    0x01 
       db    0x01 
       db    0x01 
       db    0x01 
       db    0x01 
       db    0x01 
       db    0x01 
       db    0x01 
       db    0x00 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
BrigandArmAndBody_1:
       db    0x11 
       db    0x4D 
       db    0x00 
       db    0x05 
       db    0xE6 
       db    0x2C 
       db    0x00 
       db    0x04 
       db    0x08 
       db    0xFC 
       db    0x04 
       db    0xFB 
       db    0xFF 
       db    0xFC 
       db    0xFD 
       db    0xEC 
       db    0x06 
       db    0x00 
       db    0x0C 
       db    0x1F 
       db    0x00 
       db    0x04 
       db    0xF1 
       db    0x10 
       db    0x0F 
       db    0x02 
       db    0x00 
       db    0x02 
       db    0xF8 
       db    0x06 
       db    0x08 
       db    0xEF 
       db    0x00 
       db    0xFA 
       db    0xFC 
       db    0x00 
       db    0x04 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
BrigandArmAndBody_2:
       db    0x0D 
       db    0x37 
       db    0x00 
       db    0x12 
       db    0xE8 
       db    0xFD 
       db    0xDD 
       db    0x1A 
       db    0x01 
       db    0x06 
       db    0x04 
       db    0xFE 
       db    0x04 
       db    0xFC 
       db    0x01 
       db    0xFC 
       db    0xFD 
       db    0xFB 
       db    0x02 
       db    0x0F 
       db    0x1C 
       db    0xFC 
       db    0x0F 
       db    0xF0 
       db    0xFB 
       db    0xFA 
       db    0x0A 
       db    0x01 
       db    0x02 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
BrigandHead_1:
       db    0x16 
       db    0x54 
       db    0x00 
       db    0x04 
       db    0xFC 
       db    0xF8 
       db    0x01 
       db    0x04 
       db    0xFB 
       db    0x0C 
       db    0x04 
       db    0xFC 
       db    0x04 
       db    0x2D 
       db    0x00 
       db    0xFC 
       db    0xFB 
       db    0x02 
       db    0xF7 
       db    0xF0 
       db    0xE6 
       db    0x13 
       db    0x03 
       db    0xFB 
       db    0xF2 
       db    0x0C 
       db    0x06 
       db    0xF4 
       db    0xFA 
       db    0x02 
       db    0x0A 
       db    0xE9 
       db    0xF9 
       db    0x06 
       db    0x1F 
       db    0xF7 
       db    0xFE 
       db    0xFD 
       db    0x0A 
       db    0x06 
       db    0x03 
       db    0x04 
       db    0xFA 
       db    0xF9 
       db    0xF9 
       db    0xF5 
       db    0x0B 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
BrigandArmAndBody_3:
       db    0x1B 
       db    0x15 
       db    0x00 
       db    0x0F 
       db    0xF2 
       db    0x1E 
       db    0xD9 
       db    0xF6 
       db    0xDD 
       db    0x20 
       db    0xF1 
       db    0x07 
       db    0x05 
       db    0xFE 
       db    0x06 
       db    0xFC 
       db    0x01 
       db    0xFB 
       db    0xFF 
       db    0xF8 
       db    0x0A 
       db    0x12 
       db    0x19 
       db    0x00 
       db    0x0F 
       db    0xEF 
       db    0x00 
       db    0xFC 
       db    0x08 
       db    0x04 
       db    0x08 
       db    0x0D 
       db    0x01 
       db    0xFA 
       db    0x03 
       db    0x06 
       db    0x04 
       db    0x07 
       db    0xF4 
       db    0xF6 
       db    0xFF 
       db    0x05 
       db    0xF7 
       db    0xF3 
       db    0xFF 
       db    0xFE 
       db    0x06 
       db    0x07 
       db    0xFD 
       db    0xF9 
       db    0x0C 
       db    0x03 
       db    0x07 
       db    0x0B 
       db    0x03 
       db    0x0A 
       db    0xF5 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
BrigandHead_2:
       db    0x20 
       db    0x70 
       db    0x00 
       db    0x00 
       db    0xF8 
       db    0xF6 
       db    0xEF 
       db    0x0F 
       db    0x01 
       db    0x01 
       db    0xF5 
       db    0xF9 
       db    0xFE 
       db    0xFD 
       db    0x07 
       db    0x09 
       db    0x06 
       db    0x06 
       db    0xF8 
       db    0x0E 
       db    0x1D 
       db    0x0E 
       db    0xEC 
       db    0x05 
       db    0x0A 
       db    0x06 
       db    0xF2 
       db    0xFA 
       db    0x0E 
       db    0xFB 
       db    0xF1 
       db    0xF3 
       db    0x0E 
       db    0xFD 
       db    0xE2 
       db    0xF9 
       db    0xFB 
       db    0x00 
       db    0xF7 
       db    0xEA 
       db    0xEC 
       db    0x13 
       db    0xFE 
       db    0xF8 
       db    0xF3 
       db    0x0D 
       db    0x04 
       db    0xF3 
       db    0xFC 
       db    0x04 
       db    0x09 
       db    0xE8 
       db    0x00 
       db    0x0E 
       db    0x1D 
       db    0xF7 
       db    0xFF 
       db    0xFF 
       db    0x0B 
       db    0x07 
       db    0x02 
       db    0x02 
       db    0xF9 
       db    0xF8 
       db    0xFA 
       db    0xF8 
       db    0x0E 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
BrigandArmAndBody_4:
       db    0x1B 
       db    0x15 
       db    0x00 
       db    0x0F 
       db    0xF3 
       db    0x1B 
       db    0xD5 
       db    0xF1 
       db    0xEC 
       db    0x13 
       db    0xE7 
       db    0xFE 
       db    0xF4 
       db    0x07 
       db    0xFA 
       db    0x0B 
       db    0x08 
       db    0xFB 
       db    0x07 
       db    0xF5 
       db    0x1B 
       db    0x14 
       db    0x0F 
       db    0x07 
       db    0x15 
       db    0xEF 
       db    0x00 
       db    0xFC 
       db    0x08 
       db    0x04 
       db    0x08 
       db    0x0D 
       db    0x01 
       db    0xFA 
       db    0x03 
       db    0x06 
       db    0x04 
       db    0x07 
       db    0xF4 
       db    0xF6 
       db    0xFF 
       db    0x05 
       db    0xF7 
       db    0xF3 
       db    0xFF 
       db    0xFE 
       db    0x06 
       db    0x07 
       db    0xFD 
       db    0xF9 
       db    0x0C 
       db    0x03 
       db    0x07 
       db    0x0B 
       db    0x03 
       db    0x0A 
       db    0xF5 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
BrigandArmAndBody_5:
       db    0x1D 
       db    0x15 
       db    0x00 
       db    0x0F 
       db    0xF3 
       db    0x1A 
       db    0xE4 
       db    0x06 
       db    0xF1 
       db    0xFB 
       db    0xF0 
       db    0xF1 
       db    0x09 
       db    0xFC 
       db    0xFD 
       db    0x07 
       db    0xFA 
       db    0xEF 
       db    0xF8 
       db    0xFC 
       db    0xF7 
       db    0x11 
       db    0xFB 
       db    0x12 
       db    0x0B 
       db    0x10 
       db    0x0E 
       db    0x0D 
       db    0x1C 
       db    0xEF 
       db    0x00 
       db    0xFC 
       db    0x08 
       db    0x04 
       db    0x08 
       db    0x0D 
       db    0x01 
       db    0xFA 
       db    0x03 
       db    0x06 
       db    0x04 
       db    0x07 
       db    0xF4 
       db    0xF6 
       db    0xFF 
       db    0x05 
       db    0xF7 
       db    0xF3 
       db    0xFF 
       db    0xFE 
       db    0x06 
       db    0x07 
       db    0xFD 
       db    0xF9 
       db    0x0C 
       db    0x03 
       db    0x07 
       db    0x0B 
       db    0x03 
       db    0x0A 
       db    0xF5 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
BrigandArmAndBody_6:
       db    0x1E 
       db    0x15 
       db    0x00 
       db    0x0F 
       db    0xF3 
       db    0x17 
       db    0xDF 
       db    0xF8 
       db    0xF0 
       db    0xED 
       db    0x02 
       db    0xFC 
       db    0x09 
       db    0xFD 
       db    0x00 
       db    0xFF 
       db    0xFD 
       db    0xFB 
       db    0x06 
       db    0xF8 
       db    0xFF 
       db    0xFF 
       db    0xF5 
       db    0x0F 
       db    0xF7 
       db    0x19 
       db    0xF5 
       db    0x19 
       db    0x0E 
       db    0x13 
       db    0x19 
       db    0xEF 
       db    0x00 
       db    0xFC 
       db    0x08 
       db    0x04 
       db    0x08 
       db    0x0D 
       db    0x01 
       db    0xFA 
       db    0x03 
       db    0x06 
       db    0x04 
       db    0x07 
       db    0xF4 
       db    0xF6 
       db    0xFF 
       db    0x05 
       db    0xF7 
       db    0xF3 
       db    0xFF 
       db    0xFE 
       db    0x06 
       db    0x07 
       db    0xFD 
       db    0xF9 
       db    0x0C 
       db    0x03 
       db    0x07 
       db    0x0B 
       db    0x03 
       db    0x0A 
       db    0xF5 


; Vector list:
;
;	((count - 1) | 0x80) => Move to first point
;	list of (y,x) pairs.
 
BrigandExploding_RightArm:
       db    0x8B 
       db    0xE4 
       db    0x00 
       db    0x0F 
       db    0xF2 
       db    0x1E 
       db    0xD9 
       db    0xF6 
       db    0xDD 
       db    0x20 
       db    0xF1 
       db    0x07 
       db    0x05 
       db    0xFE 
       db    0x06 
       db    0xFC 
       db    0x01 
       db    0xFB 
       db    0xFF 
       db    0xF8 
       db    0x0A 
       db    0x12 
       db    0x19 
       db    0x00 
       db    0x0F 


; Vector list:
;
;	((count - 1) | 0x80) => Move to first point
;	list of (y,x) pairs.
 
BrigandExploding_LeftArm:
       db    0x8D 
       db    0xE4 
       db    0x00 
       db    0x0F 
       db    0x0D 
       db    0x1A 
       db    0x1C 
       db    0x06 
       db    0x0F 
       db    0xFB 
       db    0x10 
       db    0xF1 
       db    0xF7 
       db    0xFC 
       db    0x03 
       db    0x07 
       db    0x06 
       db    0xEF 
       db    0x08 
       db    0xFC 
       db    0x09 
       db    0x11 
       db    0x05 
       db    0x12 
       db    0xF5 
       db    0x10 
       db    0xF2 
       db    0x0D 
       db    0xE4 


; Vector list:
;
;	((count - 1) | 0x80) => Move to first point
;	list of (y,x) pairs.
 
BrigandExploding_Head:
       db    0x9B 
       db    0x36 
       db    0xE6 
       db    0x0F 
       db    0x01 
       db    0x06 
       db    0xF8 
       db    0x0E 
       db    0x1D 
       db    0x0E 
       db    0xEC 
       db    0x05 
       db    0x0A 
       db    0x06 
       db    0xF2 
       db    0xFA 
       db    0x0E 
       db    0xFB 
       db    0xF1 
       db    0xF3 
       db    0x0E 
       db    0xFD 
       db    0xE2 
       db    0xF9 
       db    0xFB 
       db    0x00 
       db    0xF7 
       db    0xEA 
       db    0xEC 
       db    0x13 
       db    0xFE 
       db    0xF8 
       db    0xF3 
       db    0x0D 
       db    0x04 
       db    0xF3 
       db    0xFC 
       db    0x04 
       db    0x09 
       db    0xE8 
       db    0x00 
       db    0x0E 
       db    0x1D 
       db    0xF7 
       db    0xFF 
       db    0xF8 
       db    0x0E 
       db    0xEF 
       db    0x00 
       db    0xFC 
       db    0x08 
       db    0x07 
       db    0x0E 
       db    0x0B 
       db    0x03 
       db    0x0A 
       db    0xF5 

; Animation table 
MagicianRightSide_Table:
       dw    MagicianRightSide1 
       dw    MagicianRightSide1 
       dw    MagicianRightSide1 
       dw    MagicianRightSide2 
       dw    MagicianRightSide3 
       dw    MagicianRightSide4 
       dw    MagicianRightSide3 
       dw    MagicianRightSide4 
       dw    MagicianRightSide5 
       dw    MagicianRightSide4 
       dw    MagicianRightSide4 
       dw    0x0000 

; Animation table 
MagicianLeftSide_Table:
       dw    MagicianLeftSide1 
       dw    MagicianLeftSide1 
       dw    MagicianLeftSide1 
       dw    MagicianLeftSide2 
       dw    MagicianLeftSide3 
       dw    MagicianLeftSide4 
       dw    MagicianLeftSide3 
       dw    MagicianLeftSide4 
       dw    MagicianLeftSide5 
       dw    MagicianLeftSide4 
       dw    MagicianLeftSide4 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
MagicianRightSide1:
       db    0x21 
       db    0xFF 
       db    0x02 
       db    0x04 
       db    0x02 
       db    0xFE 
       db    0xFC 
       db    0x02 
       db    0xFC 
       db    0xFC 
       db    0x02 
       db    0x08 
       db    0xF8 
       db    0x06 
       db    0x04 
       db    0xFC 
       db    0x02 
       db    0x02 
       db    0x02 
       db    0x02 
       db    0xFC 
       db    0x00 
       db    0xFA 
       db    0xFC 
       db    0xFF 
       db    0x06 
       db    0xFF 
       db    0x02 
       db    0x08 
       db    0x02 
       db    0x02 
       db    0x00 
       db    0x08 
       db    0xFE 
       db    0x02 
       db    0xFE 
       db    0x08 
       db    0xFA 
       db    0xFF 
       db    0x04 
       db    0xFF 
       db    0x00 
       db    0xFA 
       db    0xFA 
       db    0x04 
       db    0xFE 
       db    0xFE 
       db    0xFC 
       db    0x08 
       db    0xE8 
       db    0x04 
       db    0xF2 
       db    0xFA 
       db    0x18 
       db    0xFC 
       db    0xDA 
       db    0x06 
       db    0xF8 
       db    0xF6 
       db    0x06 
       db    0xFC 
       db    0xF6 
       db    0xF8 
       db    0x04 
       db    0x04 
       db    0xFC 
       db    0x0E 
       db    0x0A 
       db    0x02 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
MagicianLeftSide1:
       db    0x17 
       db    0xFF 
       db    0xFE 
       db    0x08 
       db    0xF8 
       db    0x06 
       db    0x04 
       db    0x02 
       db    0x04 
       db    0xFC 
       db    0x02 
       db    0x04 
       db    0x02 
       db    0xFE 
       db    0x04 
       db    0xFC 
       db    0xFE 
       db    0x02 
       db    0xFE 
       db    0x02 
       db    0x04 
       db    0xFA 
       db    0x04 
       db    0xF8 
       db    0xF8 
       db    0x01 
       db    0xFE 
       db    0xFF 
       db    0xFE 
       db    0x06 
       db    0xFA 
       db    0xFC 
       db    0xF8 
       db    0xE8 
       db    0xFC 
       db    0xF2 
       db    0x06 
       db    0x18 
       db    0x04 
       db    0xDA 
       db    0xFA 
       db    0xF4 
       db    0x0A 
       db    0x04 
       db    0xFC 
       db    0xFC 
       db    0xFC 
       db    0x09 
       db    0xFF 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
MagicianRightSide2:
       db    0x26 
       db    0xFF 
       db    0x02 
       db    0x04 
       db    0x02 
       db    0xFE 
       db    0xFC 
       db    0x02 
       db    0xFC 
       db    0xFC 
       db    0x02 
       db    0x08 
       db    0xF8 
       db    0x06 
       db    0x04 
       db    0xFC 
       db    0x02 
       db    0x02 
       db    0x02 
       db    0x02 
       db    0xFC 
       db    0x00 
       db    0xFA 
       db    0xFC 
       db    0xFF 
       db    0x06 
       db    0xFF 
       db    0x02 
       db    0x08 
       db    0x02 
       db    0x02 
       db    0x00 
       db    0x08 
       db    0xFE 
       db    0x02 
       db    0xFE 
       db    0x08 
       db    0xFA 
       db    0xFF 
       db    0x04 
       db    0xFF 
       db    0x00 
       db    0xFA 
       db    0xFA 
       db    0x04 
       db    0xFE 
       db    0xFE 
       db    0xFC 
       db    0x08 
       db    0xEE 
       db    0x10 
       db    0xFA 
       db    0x04 
       db    0x04 
       db    0xFA 
       db    0xFE 
       db    0x00 
       db    0x02 
       db    0xFE 
       db    0x02 
       db    0x04 
       db    0xF4 
       db    0xF2 
       db    0x10 
       db    0xF8 
       db    0xDA 
       db    0x06 
       db    0xF8 
       db    0xF6 
       db    0x06 
       db    0xFC 
       db    0xF6 
       db    0xF8 
       db    0x04 
       db    0x04 
       db    0xFC 
       db    0x0E 
       db    0x0A 
       db    0x02 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
MagicianLeftSide2:
       db    0x1C 
       db    0xFF 
       db    0xFE 
       db    0x08 
       db    0xF8 
       db    0x06 
       db    0x04 
       db    0x02 
       db    0x04 
       db    0xFC 
       db    0x02 
       db    0x04 
       db    0x02 
       db    0xFE 
       db    0x04 
       db    0xFC 
       db    0xFE 
       db    0x02 
       db    0xFE 
       db    0x02 
       db    0x04 
       db    0xFA 
       db    0x04 
       db    0xF8 
       db    0xF8 
       db    0x01 
       db    0xFE 
       db    0xFF 
       db    0xFE 
       db    0x06 
       db    0xFA 
       db    0xFC 
       db    0xF8 
       db    0xEE 
       db    0xF0 
       db    0xFA 
       db    0xFC 
       db    0x04 
       db    0x06 
       db    0xFE 
       db    0x00 
       db    0x02 
       db    0x02 
       db    0x02 
       db    0xFC 
       db    0xF4 
       db    0x0E 
       db    0x10 
       db    0x08 
       db    0xDA 
       db    0xFA 
       db    0xF4 
       db    0x0A 
       db    0x04 
       db    0xFC 
       db    0xFC 
       db    0xFC 
       db    0x09 
       db    0xFF 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
MagicianRightSide3:
       db    0x2A 
       db    0xFF 
       db    0x02 
       db    0x04 
       db    0x02 
       db    0xFE 
       db    0xFC 
       db    0x02 
       db    0xFC 
       db    0xFC 
       db    0x02 
       db    0x08 
       db    0xF8 
       db    0x06 
       db    0x04 
       db    0xFC 
       db    0x02 
       db    0x02 
       db    0x02 
       db    0x02 
       db    0xFC 
       db    0x00 
       db    0xFA 
       db    0xFC 
       db    0xFF 
       db    0x06 
       db    0xFF 
       db    0x02 
       db    0x08 
       db    0x02 
       db    0x02 
       db    0x00 
       db    0x08 
       db    0xFE 
       db    0x02 
       db    0xFE 
       db    0x08 
       db    0xFA 
       db    0xFF 
       db    0x04 
       db    0xFF 
       db    0x00 
       db    0xFA 
       db    0xFA 
       db    0x04 
       db    0xFE 
       db    0xFE 
       db    0xFC 
       db    0x08 
       db    0xFA 
       db    0x02 
       db    0x04 
       db    0x0C 
       db    0xFC 
       db    0x02 
       db    0xFA 
       db    0xFE 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0xFE 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0xFE 
       db    0x04 
       db    0x00 
       db    0xF4 
       db    0x00 
       db    0xF6 
       db    0xF8 
       db    0x0C 
       db    0xF6 
       db    0xDA 
       db    0x06 
       db    0xF8 
       db    0xF6 
       db    0x06 
       db    0xFC 
       db    0xF6 
       db    0xF8 
       db    0x04 
       db    0x04 
       db    0xFC 
       db    0x0E 
       db    0x0A 
       db    0x02 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
MagicianLeftSide3:
       db    0x20 
       db    0xFF 
       db    0xFE 
       db    0x08 
       db    0xF8 
       db    0x06 
       db    0x04 
       db    0x02 
       db    0x04 
       db    0xFC 
       db    0x02 
       db    0x04 
       db    0x02 
       db    0xFE 
       db    0x04 
       db    0xFC 
       db    0xFE 
       db    0x02 
       db    0xFE 
       db    0x02 
       db    0x04 
       db    0xFA 
       db    0x04 
       db    0xF8 
       db    0xF8 
       db    0x01 
       db    0xFE 
       db    0xFF 
       db    0xFE 
       db    0x06 
       db    0xFA 
       db    0xFC 
       db    0xF8 
       db    0xFA 
       db    0xFE 
       db    0x04 
       db    0xF4 
       db    0xFC 
       db    0xFE 
       db    0xFA 
       db    0x02 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0x02 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0x02 
       db    0x04 
       db    0x00 
       db    0xF4 
       db    0x00 
       db    0xF6 
       db    0x08 
       db    0x0C 
       db    0x09 
       db    0xDA 
       db    0xFA 
       db    0xF4 
       db    0x0A 
       db    0x04 
       db    0xFC 
       db    0xFC 
       db    0xFC 
       db    0x09 
       db    0xFF 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
MagicianRightSide4:
       db    0x2A 
       db    0xFF 
       db    0x02 
       db    0x04 
       db    0x02 
       db    0xFE 
       db    0xFC 
       db    0x02 
       db    0xFC 
       db    0xFC 
       db    0x02 
       db    0x08 
       db    0xF8 
       db    0x06 
       db    0x04 
       db    0xFC 
       db    0x02 
       db    0x02 
       db    0x02 
       db    0x02 
       db    0xFC 
       db    0x00 
       db    0xFA 
       db    0xFC 
       db    0xFF 
       db    0x06 
       db    0xFF 
       db    0x02 
       db    0x08 
       db    0x02 
       db    0x02 
       db    0x00 
       db    0x08 
       db    0xFE 
       db    0x02 
       db    0xFE 
       db    0x08 
       db    0xFA 
       db    0xFF 
       db    0x04 
       db    0xFF 
       db    0x00 
       db    0xFA 
       db    0xFA 
       db    0x04 
       db    0xFE 
       db    0xFE 
       db    0xFC 
       db    0x08 
       db    0xFA 
       db    0x02 
       db    0x0E 
       db    0x0E 
       db    0xFE 
       db    0x04 
       db    0xF8 
       db    0x02 
       db    0x06 
       db    0xFE 
       db    0xFC 
       db    0x00 
       db    0x04 
       db    0xFE 
       db    0xFA 
       db    0xFC 
       db    0x06 
       db    0x00 
       db    0xF4 
       db    0x00 
       db    0xEE 
       db    0xF6 
       db    0x0C 
       db    0xF7 
       db    0xDA 
       db    0x06 
       db    0xF8 
       db    0xF6 
       db    0x06 
       db    0xFC 
       db    0xF6 
       db    0xF8 
       db    0x04 
       db    0x04 
       db    0xFC 
       db    0x0E 
       db    0x0A 
       db    0x02 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
MagicianLeftSide4:
       db    0x20 
       db    0xFF 
       db    0xFE 
       db    0x08 
       db    0xF8 
       db    0x06 
       db    0x04 
       db    0x02 
       db    0x04 
       db    0xFC 
       db    0x02 
       db    0x04 
       db    0x02 
       db    0xFE 
       db    0x04 
       db    0xFC 
       db    0xFE 
       db    0x02 
       db    0xFE 
       db    0x02 
       db    0x04 
       db    0xFA 
       db    0x04 
       db    0xF8 
       db    0xF8 
       db    0x01 
       db    0xFE 
       db    0xFF 
       db    0xFE 
       db    0x06 
       db    0xFA 
       db    0xFC 
       db    0xF8 
       db    0xFA 
       db    0xFE 
       db    0x0E 
       db    0xF2 
       db    0xFE 
       db    0xFC 
       db    0xF8 
       db    0xFE 
       db    0x06 
       db    0x02 
       db    0xFC 
       db    0x00 
       db    0x04 
       db    0x02 
       db    0xFA 
       db    0x04 
       db    0x06 
       db    0x00 
       db    0xF4 
       db    0x00 
       db    0xEE 
       db    0x0A 
       db    0x0C 
       db    0x09 
       db    0xDA 
       db    0xFA 
       db    0xF4 
       db    0x0A 
       db    0x04 
       db    0xFC 
       db    0xFC 
       db    0xFC 
       db    0x09 
       db    0xFF 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
MagicianRightSide5:
       db    0x29 
       db    0xFF 
       db    0x02 
       db    0x04 
       db    0x02 
       db    0xFE 
       db    0xFC 
       db    0x02 
       db    0xFC 
       db    0xFC 
       db    0x02 
       db    0x08 
       db    0xF8 
       db    0x06 
       db    0x04 
       db    0xFC 
       db    0x02 
       db    0x02 
       db    0x02 
       db    0x02 
       db    0xFC 
       db    0x00 
       db    0xFA 
       db    0xFC 
       db    0xFF 
       db    0x06 
       db    0xFF 
       db    0x02 
       db    0x08 
       db    0x02 
       db    0x02 
       db    0x00 
       db    0x08 
       db    0xFE 
       db    0x02 
       db    0xFE 
       db    0x08 
       db    0xFA 
       db    0xFF 
       db    0x04 
       db    0xFF 
       db    0x00 
       db    0xFA 
       db    0xFA 
       db    0x04 
       db    0xFE 
       db    0xFE 
       db    0xFC 
       db    0x08 
       db    0xFA 
       db    0x02 
       db    0x0E 
       db    0x0E 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0x02 
       db    0x04 
       db    0x06 
       db    0xFA 
       db    0x00 
       db    0xF8 
       db    0xF4 
       db    0x04 
       db    0x00 
       db    0xF4 
       db    0x00 
       db    0xEE 
       db    0xF6 
       db    0x0C 
       db    0xF7 
       db    0xDA 
       db    0x06 
       db    0xF8 
       db    0xF6 
       db    0x06 
       db    0xFC 
       db    0xF6 
       db    0xF8 
       db    0x04 
       db    0x04 
       db    0xFC 
       db    0x0E 
       db    0x0A 
       db    0x02 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
MagicianLeftSide5:
       db    0x1F 
       db    0xFF 
       db    0xFE 
       db    0x08 
       db    0xF8 
       db    0x06 
       db    0x04 
       db    0x02 
       db    0x04 
       db    0xFC 
       db    0x02 
       db    0x04 
       db    0x02 
       db    0xFE 
       db    0x04 
       db    0xFC 
       db    0xFE 
       db    0x02 
       db    0xFE 
       db    0x02 
       db    0x04 
       db    0xFA 
       db    0x04 
       db    0xF8 
       db    0xF8 
       db    0x01 
       db    0xFE 
       db    0xFF 
       db    0xFE 
       db    0x06 
       db    0xFA 
       db    0xFC 
       db    0xF8 
       db    0xFA 
       db    0xFE 
       db    0x0E 
       db    0xF2 
       db    0x04 
       db    0x00 
       db    0xFE 
       db    0xFE 
       db    0x04 
       db    0xFA 
       db    0xFA 
       db    0x00 
       db    0xF8 
       db    0x0C 
       db    0x04 
       db    0x00 
       db    0xF4 
       db    0x00 
       db    0xEE 
       db    0x0A 
       db    0x0C 
       db    0x09 
       db    0xDA 
       db    0xFA 
       db    0xF4 
       db    0x0A 
       db    0x04 
       db    0xFC 
       db    0xFC 
       db    0xFC 
       db    0x09 
       db    0xFF 

ObjectVectorTable:
       dw    DeadTree 
       dw    PineTree 
       dw    MapleTree 
       dw    ElmTree 
       dw    DeadTree 
       dw    0x00F0 
       dw    0x00F2 
       dw    0x00F4 
       dw    0x0080 
       dw    0x0082 
       dw    0x0084 
       dw    0x0086 
       dw    0x0088 
       dw    0x008A 
       dw    0x00E0 
       dw    0x00E2 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
DeadTree:
       db    0x1C 
       db    0xF8 
       db    0x10 
       db    0x0C 
       db    0xFA 
       db    0x38 
       db    0x0C 
       db    0x18 
       db    0x20 
       db    0x18 
       db    0xF4 
       db    0x10 
       db    0x20 
       db    0xF8 
       db    0x10 
       db    0x08 
       db    0xF0 
       db    0x08 
       db    0x08 
       db    0xFC 
       db    0x08 
       db    0x04 
       db    0xF8 
       db    0xF8 
       db    0xF8 
       db    0xF2 
       db    0xD4 
       db    0xE8 
       db    0x08 
       db    0xF0 
       db    0xE0 
       db    0x20 
       db    0xE0 
       db    0x18 
       db    0x10 
       db    0x10 
       db    0xF0 
       db    0xF0 
       db    0x0C 
       db    0xE6 
       db    0xEC 
       db    0xF0 
       db    0x0C 
       db    0xF0 
       db    0xF0 
       db    0x08 
       db    0xF8 
       db    0xF8 
       db    0x08 
       db    0x0A 
       db    0x14 
       db    0xF0 
       db    0x0E 
       db    0xD0 
       db    0xF0 
       db    0xE0 
       db    0xE0 
       db    0x18 
       db    0x34 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
PineTree:
       db    0x0A 
       db    0x23 
       db    0x00 
       db    0x00 
       db    0xDD 
       db    0x2D 
       db    0x0F 
       db    0x00 
       db    0xFB 
       db    0x37 
       db    0x0A 
       db    0x00 
       db    0xFB 
       db    0x64 
       db    0x14 
       db    0x83 
       db    0x19 
       db    0x00 
       db    0xF6 
       db    0xA6 
       db    0x14 
       db    0x00 
       db    0xDD 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
MapleTree:
       db    0x15 
       db    0xF8 
       db    0x10 
       db    0x0C 
       db    0xFA 
       db    0x38 
       db    0x0C 
       db    0x10 
       db    0x16 
       db    0xE0 
       db    0x20 
       db    0x40 
       db    0x30 
       db    0x30 
       db    0x00 
       db    0x30 
       db    0xA0 
       db    0x00 
       db    0xC0 
       db    0xC0 
       db    0xD0 
       db    0xD0 
       db    0xF8 
       db    0xD0 
       db    0x30 
       db    0x2C 
       db    0x30 
       db    0xF4 
       db    0x26 
       db    0x05 
       db    0xF0 
       db    0xF4 
       db    0xEC 
       db    0x0A 
       db    0xF4 
       db    0xF8 
       db    0xF8 
       db    0xF8 
       db    0x0A 
       db    0xD0 
       db    0xF0 
       db    0xE0 
       db    0xE0 
       db    0x18 
       db    0x34 


; Vector list:
;
;	0 => each point has its own drawing mode flag
;	list of (mode,y,x) triplets, where mode is:
;
;	0x00 => move to next point
;	0xFF => draw to next point
;     0x01 => end of list
 
ElmTree:
       db    0x00 
       db    0xFF 
       db    0x50 
       db    0x00 
       db    0xFF 
       db    0x4A 
       db    0x28 
       db    0x00 
       db    0xD8 
       db    0xE2 
       db    0xFF 
       db    0x1E 
       db    0xE2 
       db    0x00 
       db    0xBF 
       db    0x14 
       db    0xFF 
       db    0x00 
       db    0xDD 
       db    0x00 
       db    0x0F 
       db    0xF1 
       db    0xFF 
       db    0x50 
       db    0x0F 
       db    0x00 
       db    0x18 
       db    0xEC 
       db    0xFF 
       db    0x30 
       db    0x28 
       db    0xFF 
       db    0xF6 
       db    0x20 
       db    0x00 
       db    0xEA 
       db    0x20 
       db    0xFF 
       db    0xE8 
       db    0x1E 
       db    0xFF 
       db    0xE0 
       db    0xF6 
       db    0x00 
       db    0xE8 
       db    0xF1 
       db    0xFF 
       db    0xC8 
       db    0xC8 
       db    0x01 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
Flamoid:
       db    0x08 
       db    0x02 
       db    0x00 
       db    0x03 
       db    0xFB 
       db    0xFB 
       db    0x03 
       db    0xFB 
       db    0xFD 
       db    0x03 
       db    0x05 
       db    0xFD 
       db    0x05 
       db    0x05 
       db    0xFD 
       db    0x05 
       db    0x03 
       db    0xFC 
       db    0xFA 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
DarkTowerRightHalf:
       db    0x11 
       db    0xFC 
       db    0x06 
       db    0xEE 
       db    0x02 
       db    0x02 
       db    0x08 
       db    0x04 
       db    0x00 
       db    0x02 
       db    0x08 
       db    0xF8 
       db    0x10 
       db    0x08 
       db    0xF0 
       db    0xFF 
       db    0xFC 
       db    0x37 
       db    0xFA 
       db    0x06 
       db    0xF2 
       db    0xFA 
       db    0xF2 
       db    0x06 
       db    0xFE 
       db    0x0A 
       db    0x12 
       db    0xF6 
       db    0xFE 
       db    0xD2 
       db    0x00 
       db    0xFC 
       db    0x05 
       db    0xF0 
       db    0x01 
       db    0x00 
       db    0xF2 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
DarkTowerLeftHalf:
       db    0x10 
       db    0xFC 
       db    0xFA 
       db    0xEE 
       db    0xFE 
       db    0x02 
       db    0xFA 
       db    0x0A 
       db    0xFC 
       db    0x04 
       db    0x02 
       db    0x02 
       db    0xFE 
       db    0xFC 
       db    0xFC 
       db    0xF8 
       db    0xFC 
       db    0xFC 
       db    0xF0 
       db    0x04 
       db    0x10 
       db    0x08 
       db    0x04 
       db    0x03 
       db    0x03 
       db    0x2D 
       db    0x05 
       db    0x06 
       db    0xFE 
       db    0x0A 
       db    0x12 
       db    0xF6 
       db    0x0E 
       db    0xFA 
       db    0xFE 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
TowerDoor:
       db    0x08 
       db    0x4C 
       db    0x06 
       db    0x10 
       db    0x1C 
       db    0xF0 
       db    0x1E 
       db    0xB4 
       db    0x08 
       db    0x4C 
       db    0xF8 
       db    0x10 
       db    0xE2 
       db    0xF0 
       db    0x1A 
       db    0xB8 
       db    0x06 
       db    0x00 
       db    0xBE 


; Vector list:
;
;	0 => each point has its own drawing mode flag
;	list of (mode,y,x) triplets, where mode is:
;
;	0x00 => move to next point
;	0xFF => draw to next point
;     0x01 => end of list
 
KeyHole:
       db    0x00 
       db    0xFF 
       db    0xFE 
       db    0xFE 
       db    0xFF 
       db    0xFE 
       db    0x01 
       db    0xFF 
       db    0xFC 
       db    0xFF 
       db    0xFF 
       db    0x00 
       db    0x04 
       db    0xFF 
       db    0x04 
       db    0xFF 
       db    0xFF 
       db    0x02 
       db    0x01 
       db    0xFF 
       db    0x02 
       db    0xFE 
       db    0x00 
       db    0x02 
       db    0xFE 
       db    0xFF 
       db    0xFE 
       db    0xFE 
       db    0xFF 
       db    0xF8 
       db    0x00 
       db    0xFF 
       db    0xFE 
       db    0x02 
       db    0xFF 
       db    0x00 
       db    0x04 
       db    0xFF 
       db    0x02 
       db    0x02 
       db    0xFF 
       db    0x08 
       db    0x00 
       db    0xFF 
       db    0x02 
       db    0xFE 
       db    0xFF 
       db    0x00 
       db    0xFC 
       db    0x01 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
Key:
       db    0x12 
       db    0x00 
       db    0x14 
       db    0xFA 
       db    0x02 
       db    0x00 
       db    0x0C 
       db    0x08 
       db    0x04 
       db    0x08 
       db    0xFC 
       db    0x00 
       db    0xF4 
       db    0xFA 
       db    0xFE 
       db    0x00 
       db    0xDE 
       db    0xF8 
       db    0x00 
       db    0x00 
       db    0x02 
       db    0x04 
       db    0x00 
       db    0x00 
       db    0x04 
       db    0xFC 
       db    0x00 
       db    0x00 
       db    0x02 
       db    0x02 
       db    0x00 
       db    0x00 
       db    0x04 
       db    0xFE 
       db    0x00 
       db    0x00 
       db    0x02 
       db    0x04 
       db    0x00 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
Arrow:
       db    0x06 
       db    0xD0 
       db    0x20 
       db    0x00 
       db    0xF0 
       db    0xE0 
       db    0x00 
       db    0x00 
       db    0xE0 
       db    0x20 
       db    0x00 
       db    0x00 
       db    0xF0 
       db    0x30 
       db    0x20 

ArrowXpositions:
       db    0xC1 
       db    0xEF 
       db    0x1C 
       db    0x4C 


; Vector list:
;
;	count - 1
;	list of (y,x) pairs.
 
BagOfGold:
       db    0x0E 
       db    0x0A 
       db    0xF6 
       db    0x0C 
       db    0x00 
       db    0x0E 
       db    0x0E 
       db    0x0A 
       db    0xF2 
       db    0xFE 
       db    0x0A 
       db    0x06 
       db    0x04 
       db    0xFC 
       db    0x06 
       db    0x06 
       db    0x0A 
       db    0xF0 
       db    0xFC 
       db    0x00 
       db    0xF4 
       db    0x00 
       db    0x0C 
       db    0xF2 
       db    0x12 
       db    0xF8 
       db    0x00 
       db    0xF2 
       db    0xF4 
       db    0x00 
       db    0xEA 

CompassPointLabels:
       dw    NorthLabel 
       dw    NorthWestLabel 
       dw    WestLabel 
       dw    SouthWestLabel 
       dw    SouthLabel 
       dw    SouthEastLabel 
       dw    EastLabel 
       dw    NorthEastLabel 

NorthLabel:
       db    "  N",0x80 

NorthWestLabel:
       db    " NW",0x80 

WestLabel:
       db    "  W",0x80 

SouthWestLabel:
       db    " SW",0x80 

SouthLabel:
       db    "  S",0x80 

SouthEastLabel:
       db    " SE",0x80 

EastLabel:
       db    "  E",0x80 

NorthEastLabel:
       db    " NE",0x80 

; These are the default values for the brigand array, which
; occupies C9E0-C9F7 (6 entries, of 4 bytes each).  The
; entries have the following meaning:
;
;          ------------------------------
;   byte 0 | 1 => animation complete    |
;          ------------------------------
;   byte 1 | animation index            |
;          ------------------------------
;   byte 2 |                            |
;          -- Ptr to brigand specifics --
;   byte 3 |                            |
;          ------------------------------
;
 
BrigandDefaults:
       db    0x01 
       db    0x00 
       dw    Brigand1Data 
       db    0x01 
       db    0x00 
       dw    Brigand2Data 
       db    0x01 
       db    0x00 
       dw    Brigand3Data 
       db    0x01 
       db    0x00 
       dw    Brigand4Data 
       db    0x01 
       db    0x00 
       dw    Brigand5Data 
       db    0x01 
       db    0x00 
       dw    Brigand6Data 

; The following 6 data blocks represent the hard (fixed)
; data associated with the 6 possible brigands (3 on the
; left side, and 3 on the right side).  Each entry is 17
; bytes long, and has the following meaning:
;
;           ------------------------------
;   byte 0  | Brigand's 16-bit Y         |
;           --                          --
;   byte 1  | Position                   |
;           ------------------------------
;   byte 2  | Brigand's 16-bit X         |
;           --                          --
;   byte 3  | Position                   |
;           ------------------------------
;   byte 4  | Flamoid's 16-bit Y         |
;           --                          --
;   byte 5  | Position                   |
;           ------------------------------
;   byte 6  | Flamoid's 16-bit X         |
;           --                          --
;   byte 7  | Position                   |
;           ------------------------------
;   byte 8  | ????                       |
;           ------------------------------
;   byte 9  | ????                       |
;           ------------------------------
;   byte A  | ????                       |
;           ------------------------------
;   byte B  | ????                       |
;           ------------------------------
;   byte C  | ????                       |
;           ------------------------------
;   byte D  | Image Flip Flag            |
;           ------------------------------
;   byte E  | Scale factor               |
;           ------------------------------
;   byte F  | Target Size (height/2)     |
;           --                          --
;   byte 10 | Target Size (width/2)      |
;           ------------------------------
;
 
Brigand1Data:
       db    0xD0 
       db    0x00 
       db    0x40 
       db    0x00 
       db    0x52 
       db    0x00 
       db    0x0C 
       db    0x00 
       db    0xF3 
       db    0x52 
       db    0x00 
       db    0x15 
       db    0x00 
       db    0x00 
       db    0x28 
       db    0x03 
       db    0x06 

Brigand2Data:
       db    0xDC 
       db    0x00 
       db    0x30 
       db    0x00 
       db    0x5E 
       db    0x00 
       db    0x08 
       db    0x00 
       db    0xF8 
       db    0x5E 
       db    0x00 
       db    0x12 
       db    0x00 
       db    0x00 
       db    0x20 
       db    0x03 
       db    0x06 

Brigand3Data:
       db    0xE2 
       db    0x00 
       db    0x26 
       db    0x00 
       db    0x66 
       db    0x00 
       db    0x05 
       db    0x00 
       db    0xF8 
       db    0x66 
       db    0x00 
       db    0x0E 
       db    0x00 
       db    0x00 
       db    0x18 
       db    0x03 
       db    0x06 

Brigand4Data:
       db    0xD0 
       db    0x00 
       db    0xC0 
       db    0x00 
       db    0x52 
       db    0x00 
       db    0xF5 
       db    0x00 
       db    0xF3 
       db    0x52 
       db    0x00 
       db    0xEC 
       db    0x00 
       db    0x01 
       db    0x28 
       db    0x03 
       db    0x06 

Brigand5Data:
       db    0xDC 
       db    0x00 
       db    0xD0 
       db    0x00 
       db    0x5E 
       db    0x00 
       db    0xF8 
       db    0x00 
       db    0xF8 
       db    0x5E 
       db    0x00 
       db    0xEE 
       db    0x00 
       db    0x01 
       db    0x20 
       db    0x03 
       db    0x06 

Brigand6Data:
       db    0xE2 
       db    0x00 
       db    0xDD 
       db    0x00 
       db    0x66 
       db    0x00 
       db    0xFB 
       db    0x00 
       db    0xF8 
       db    0x66 
       db    0x00 
       db    0xF1 
       db    0x00 
       db    0x01 
       db    0x18 
       db    0x03 
       db    0x06 

StringHeightWidthTable:
       db    0xFC 
       db    0x04 
       db    0xFC 
       db    0x06 
       db    0xFC 
       db    0x08 
       db    0xFB 
       db    0x0C 
       db    0xFB 
       db    0x0D 
       db    0xFA 
       db    0x0D 
       db    0xFA 
       db    0x10 
       db    0xF9 
       db    0x14 
       db    0xF8 
       db    0x15 
       db    0xF7 
       db    0x17 
       db    0xF6 
       db    0x18 
       db    0xF6 
       db    0x19 
       db    0xF6 
       db    0x1B 
       db    0xF5 
       db    0x1D 
       db    0xF5 
       db    0x1F 
       db    0xF4 
       db    0x21 
       db    0xF4 
       db    0x21 

; Table of function pointers 
       dw    AwardGoldKey 
       dw    AwardSilverKey 
       dw    AwardBronzeKey 
       dw    AwardBrassKey 
       dw    AwardBrassKey 
       dw    AwardBronzeKey 
       dw    AwardSilverKey 
       dw    AwardGoldKey 

; Table of function pointers 
RandomAwardsTable1:
       dw    AwardBagsOfGold 
       dw    AwardBagsOfGold 
       dw    AwardBagsOfGold 
       dw    AwardBagsOfGold 
       dw    AwardNewWarrior 
       dw    AwardBagsOfGold 
       dw    AwardBagsOfGold 
       dw    AwardNewWarrior 

; Table of function pointers 
RandomAwardsTable2:
       dw    AwardBagsOfGold 
       dw    AwardBagsOfGold 
       dw    AwardBagsOfGold 
       dw    AwardNewWarrior 
       dw    0x0000 
       dw    AwardBagsOfGold 
       dw    AwardBagsOfGold 
       dw    AwardBagsOfGold 

InventoryLabel:
       db    "PLAYER INVENTORY",0x80 

TableOfObjectsToFind:
       dw    BeGoneLabel 
       dw    GoldKeyLabel 
       dw    SilverKeyLabel 
       dw    BronzeKeyLabel 
       dw    BrassKeyLabel 
       dw    CrystalCrownLabel 
       dw    ScoutLabel 
       dw    HealerLabel 
       dw    0xCB5D 
       dw    0xCB5D 

; Pairs of (y,x) positions, used when displaying the 
; above labels 
 
ObjectPositionTable:
       db    0x7F 
       db    0xF4 
       db    0x7F 
       db    0xF0 
       db    0x7F 
       db    0xEC 
       db    0x7F 
       db    0xEC 
       db    0x7F 
       db    0xEC 
       db    0x7F 
       db    0xE4 
       db    0x7F 
       db    0xF4 
       db    0x7F 
       db    0xF4 
       db    0x7F 
       db    0xE4 
       db    0x7F 
       db    0xE4 

GoldKeyLabel:
       db    "GOLD KEY",0x80 

SilverKeyLabel:
       db    "SILVER KEY",0x80 

BronzeKeyLabel:
       db    "BRONZE KEY",0x80 

BrassKeyLabel:
       db    "BRASS KEY",0x80 

CrystalCrownLabel:
       db    "CRYSTAL CROWN",0x80 

ScoutLabel:
       db    "SCOUT",0x80 

HealerLabel:
       db    "HEALER",0x80 

YourScoreIsLabel:
       db    "YOUR SCORE IS      0",0x80 

BagsOfGoldLabel_2:
       db    "   " 

BagsOfGoldLabel:
       db    "2 BAGS OF GOLD",0x80 

ReserveTroopsLabel:
       db    "   6 RESERVE TROOPS",0x80 

NewWarriorLabel:
       db    "0 NEW WARRIOR",0x80 

BeGoneLabel:
       db    "BE GONE",0x80 

RiddleOfTheKeysLabel:
       db    0xF8 
       db    0x34 
       db    0x78 
       db    0xC0 
       db    "RIDDLE OF THE KEYS",0x80,0x00;

KeyNameLabelTable:
       dw    KeyLabel 
       dw    GoldLabel 
       dw    SilverLabel 
       dw    BronzeLabel 
       dw    BrassLabel 

KeyLabel:
       db    "KEY ? ",0x80 

GoldLabel:
       db    "GOLD  ",0x80 

SilverLabel:
       db    "SILVER",0x80 

BronzeLabel:
       db    "BRONZE",0x80 

BrassLabel:
       db    "BRASS ",0x80 

EnterVictoriousWarriorLabel:
       db    0xF8 
       db    0x40 
       db    0x38 
       db    0xE4 
       db    "ENTER,",0x80 
       db    0xFA 
       db    0x40 
       db    0x18 
       db    0xD2 
       db    "VICTORIOUS",0x80 
       db    0xFA 
       db    0x40 
       db    0x04 
       db    0xDE 
       db    "WARRIOR",0x80,0x00 

GameOverLabel:
       db    0xFA 
       db    0x38 
       db    0xB0 
       db    0xD8 
       db    "GAME OVER",0x80,0x00 

YourFirstWarriorLabel:
       db    0xFA 
       db    0x38 
       db    0x50 
       db    0xD8 
       db    "YOUR FIRST",0x80 
       db    0xFA 
       db    0x38 
       db    0x40 
       db    0xE8 
       db    "WARRIOR",0x80,0x00 

ReplacementWarriorLabel:
       db    0xFA 
       db    0x38 
       db    0x50 
       db    0xD8 
       db    "REPLACEMENT",0x80 
       db    0xFA 
       db    0x38 
       db    0x40 
       db    0xE8 
       db    "WARRIOR",0x80,0x00 

       db    0xBD