CnC_Remastered_Collection/REDALERT/DEFINES.H

//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
// software: you can redistribute it and/or modify it under the terms of 
// the GNU General Public License as published by the Free Software Foundation, 
// either version 3 of the License, or (at your option) any later version.

// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
// in the hope that it will be useful, but with permitted additional restrictions 
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
// distributed with this program. You should have received a copy of the 
// GNU General Public License along with permitted additional restrictions 
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection

/* $Header: /CounterStrike/DEFINES.H 4     3/07/97 9:55a Joe_bostic $ */
/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : Command & Conquer                                            *
 *                                                                                             *
 *                    File Name : DEFINES.H                                                    *
 *                                                                                             *
 *                   Programmer : Joe L. Bostic                                                *
 *                                                                                             *
 *                   Start Date : September 10, 1993                                           *
 *                                                                                             *
 *                  Last Update : September 10, 1993   [JLB]                                   *
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#ifndef DEFINES_H
#define DEFINES_H

/**********************************************************************
**	Language control: define the desired language for this build.
*/
//#define ENGLISH 1
//#define FRENCH 1
//#define GERMAN 1
//#define SPAIN 1	(never used)
//	- Language define is now passed in from the makefile. -

/**********************************************************************
**	Controls the nature of the game and its abilities. Only define
**	one of these values.
**
**	Internal version -- complete with scenario editor.
**	Playtest version -- no editor but does have minimal cheat keys.
**	Release version -- no editor or cheat keys -- all debugging info removed.
*/
//#define	INTERNAL_VERSION
//#define	PLAYTEST_VERSION
#define	RELEASE_VERSION

/**********************************************************************
** ColinM
** Set this to enable dongle protection
*/
//#define DONGLE


// Enable 640x400 VQ movie capability in WIN32 mode
#define MOVIE640


//#if (GERMAN | FRENCH)
//#define	BOGUSCD
//#endif

#define	FIXIT_SCORE_CRASH			// Fixes score screen crash
#define	FIXIT_MULTI_SAVE			// Fixes multiplayer save/load
#define	FIXIT_NO_COMP_ALLY		// Prevent ally with computer
#define	FIXIT_DESTNET				// Fixes -destnet parameter in Win95
#define	FIXIT_RANDOM_GAME			// Fixes random seed at start of multiplayer games
#define	FIXIT_FORCE_CD				// Forces correct CD load after scenario #1
#define	FIXIT_IP_CRASH				// Fixes crash if internet game aborts too quickly
#define	FIXIT_IP_STATS				// Fixes so vessels show up in internet stat info
#define	FIXIT_NAME_OVERRIDE     // Allows changing of unit names
#define	FIXIT_RADAR_JAMMED		// Fixes unjamming by merely starting to build a radar facility
#define	FIXIT_CAPTURE_BIB			// Fixes so that if fake is captured, you still can't build off of it.
#define	FIXIT_BASE_ANNOUNCE		// Fixes so player controlled buildings count as base when attacked.
#define	FIXIT_APTIVA_MODEM		// Fixes crash with Aptiva modem.
#define	FIXIT_FLAG_CHECK			// Disable placing building over a flag.

#define	FIXIT_ANTS              // Adds Ant Units

#define	FIXIT_CSII					// Adds Aftermath CounterStrike II units
//	ajw 9/28/98 - Note about FIXIT_CSII. Changes seem to have been made for Aftermath ("Counterstrike II") that: a) were
//	bug fixes that should never be rolled back, b) change the nature of the game, at least in multi-player. This meant
//	that the "Red Alert" executable ( == Counterstrike executable ) could no longer be built. Apparently, at the time,
//	this was justified, as it was believed that no further patches to the RA executable would ever be necessary.
//	Given that Denzil's DVD changes and my WOLAPI integration are essentially a patch, we've got a problem.
//	We've decided to level the field and make sure every who gets or patches to the new version of Red Alert, CS, AM, (and
//	their DVD equivalent(s)) will have the same executable. So we're assuming that all of the FIXIT_CSII changes are 
//	permanent (as, in fact, all prior FIXIT_'s are - makes me wonder why the old non-compiling code has to hang around
//	forever), and fixing the code so that the assumption "this is an Aftermath game" is no longer hard-coded, but can 
//	change at runtime. (Which is what should have been done when Aftermath was created.)
//	<This goes for the following three defines as well.>
#define	FIXIT_CARRIER				// Adds Aftermath aircraft carrier
#define	FIXIT_PHASETRANSPORT		// Adds Aftermath cloaking APC
//	ajw - Discovered that engineer changing fields were specifically left out of aftrmath.ini, thus this has no effect.
//	Engineer changes (and other game rule changes) are in mplayer.ini, which was loaded before aftermath-only mplayer games.
#define	FIXIT_ENGINEER				// Adds Engineer rules.ini overrides

//#define	FIXIT_FAST_LOAD			// Enables faster INI loading

// These fixes will cause the game to go out of sync.
//#define	FIXIT_ENGINEER_CAPTURE	// If building not allied, will still capture if engineer not allied with building.
//#define	FIXIT_HELI_LANDING	// Fixes so new helicopters land at free helipad
//#define	FIXIT_MINE_PASSABLE	// Fixes units not driving onto mines

/* Turn on these changes for the 1.08 patch */
#define FIXIT_PATCH_108

#ifdef FIXIT_PATCH_108
#define STEVES_LOAD_OVERRIDE // Allows loading of CONQUER.ENG instead of from mix file.
#define FIXIT_DIFFICULTY		// Fixes no difficulty level for CStrike missions
#define FIXIT_VERSION	// Fixes version playability for 1.04, 1.07 & 1.08
#define FIXIT_MODEM_LOAD_CRASH // Fixes crash after loading a modem game when names are the same
#define FIXIT_PHONELIST_CRASH // Fixes crash when clicking on an empty phonelist
#endif

//	Denotes changes made for version 3 - reunification of all existing versions and undoing of Aftermath divergence. - ajw
#define FIXIT_VERSION_3
#define DVD

// Define DVD to turn on RADVD additions/changes - Denzil
#ifdef DVD
//#define INTERNET_OFF
//#define MPEGMOVIE	//PG
//#define MCIMPEG
#endif

// Test to see if partial object drawing is any faster.
//#define	PARTIAL
#define	SORTDRAW

/**********************************************************************
**	If the scenario editor to to be active in this build then uncomment
**	the following #define line.
*/
#ifdef INTERNAL_VERSION
#define SCENARIO_EDITOR
#endif


/**********************************************************************
**	This define enables the full set of cheat keys and special
**	command line options.
*/
#if defined(INTERNAL_VERSION) || defined(PLAYTEST_VERSION)
#define CHEAT_KEYS
#endif


/**********************************************************************
**	If this is defined, the special Virgin limited cheat keys
**	are enabled. This allows the "cheat" parameter and then only
**	allows the ALT-W to win the mission.
*/
#ifdef PLAYTEST_VERSION
#define VIRGIN_CHEAT_KEYS
#endif


/**********************************************************************
**	If this is defined, then the network code will be enabled.
*/
#define NETWORK
#define TIMING_FIX	1


/**********************************************************************
** Define this to 1 to enable MPath-specific code.  Do not define
** TEN at the same time.
*/
#define MPATH	0


/**********************************************************************
** Define this to 1 to enable TEN-specific code.  Do not define
** MPATH at the same time.
*/
#define TEN		0


/**********************************************************************
**	If this is defined, the DoList is "mirrored", for memory trasher
** detection.
*/
#ifdef CHEAT_KEYS
//#define MIRROR_QUEUE
#endif


/**********************************************************************
**	This define tells the Version Number class to use the date/time-based
** version numbering system.  If this define is not set, the actual
** major/minor version numbers will be used.
*/
//#define DEV_VERSION
//#define DEV_VER_NAME


/**********************************************************************
** This define enables a special additional foreign-version-number
** after the other version number, for display purposes only.
*/
#if !defined(ENGLISH)
#define	FOREIGN_VERSION
#define	FOREIGN_VERSION_NUMBER	7
#endif


/**********************************************************************
** This is the multiplier factor to convert low resution coordinates
**	into their actual resolution counterparts.
*/
#ifdef WIN32
#define RESFACTOR	2
#else
//#undef SCENARIO_EDITOR
#define RESFACTOR 1
#endif


#define SIDEBAR_WID	80


/**********************************************************************
**	Optional parameter control for special options.
*/

/*
**	Enable the set of limited cheat key options.
*/
#ifdef VIRGIN_CHEAT_KEYS
#define	PARM_PLAYTEST		0xF7DDC227		// "PLAYTEST"
#endif

/*
**	Enable the full set of cheat key options.
*/
#ifdef CHEAT_KEYS
#ifndef PARM_PLAYTEST
#define	PARM_PLAYTEST		0xF7DDC227		// "PLAYTEST"
#endif
#endif


#define	PARM_INSTALL		0xD95C68A2		//	"FROMINSTALL"


//
// Allow normal game play in the MPath version
//
#if(MPATH)
#define	PARM_ALLOW_SOLO	0xc901c9db	// AllowSoloPlayOptions
#endif

//
// Allow normal game play in the TEN version
//
#if(TEN)
#define	PARM_ALLOW_SOLO	0xc901c9db	// AllowSoloPlayOptions
#endif

/**********************************************************************
**	Defines for verifying free disk space
*/
#define	INIT_FREE_DISK_SPACE		8388608
#define	SAVE_GAME_DISK_SPACE		 (INIT_FREE_DISK_SPACE - (1024*4096))
//#define	SAVE_GAME_DISK_SPACE		 100000


/**********************************************************************
**	This is the complete list of VQs allowed to be played in the game.
*/
typedef enum VQType {
	VQ_NONE=-1,
	VQ_AAGUN,
	VQ_MIG,
	VQ_SFROZEN,
	VQ_AIRFIELD,
	VQ_BATTLE,
	VQ_BMAP,
	VQ_BOMBRUN,
	VQ_DPTHCHRG,
	VQ_GRVESTNE,
	VQ_MONTPASS,
	VQ_MTNKFACT,
	VQ_CRONTEST,
	VQ_OILDRUM,
	VQ_ALLYEND,
	VQ_RADRRAID,
	VQ_SHIPYARD,
	VQ_SHORBOMB,
	VQ_SITDUCK,
	VQ_SLNTSRVC,
	VQ_SNOWBASE,
	VQ_EXECUTE,
	VQ_TITLE,				// Low res.
	VQ_NUKESTOK,
	VQ_V2ROCKET,
	VQ_SEARCH,
	VQ_BINOC,
	VQ_ELEVATOR,
	VQ_FROZEN,
	VQ_MCV,
	VQ_SHIPSINK,
	VQ_SOVMCV,
	VQ_TRINITY,
	VQ_ALLYMORF,
	VQ_APCESCPE,
	VQ_BRDGTILT,
	VQ_CRONFAIL,
	VQ_STRAFE,
	VQ_DESTROYR,
	VQ_DOUBLE,
	VQ_FLARE,
	VQ_SNSTRAFE,
	VQ_LANDING,
	VQ_ONTHPRWL,
	VQ_OVERRUN,
	VQ_SNOWBOMB,
	VQ_SOVCEMET,
	VQ_TAKE_OFF,
	VQ_TESLA,
	VQ_SOVIET8,
	VQ_SPOTTER,
	VQ_SCENE1,
	VQ_SCENE2,
	VQ_SCENE4,
	VQ_SOVFINAL,
	VQ_ASSESS,
	VQ_SOVIET10,
	VQ_DUD,
	VQ_MCV_LAND,
	VQ_MCVBRDGE,
	VQ_PERISCOP,
	VQ_SHORBOM1,
	VQ_SHORBOM2,
	VQ_SOVBATL,
	VQ_SOVTSTAR,
	VQ_AFTRMATH,
	VQ_SOVIET11,
	VQ_MASASSLT,
	VQ_REDINTRO,		// High res
	VQ_SOVIET1,
	VQ_SOVIET2,
	VQ_SOVIET3,
	VQ_SOVIET4,
	VQ_SOVIET5,
	VQ_SOVIET6,
	VQ_SOVIET7,
	VQ_INTRO_MOVIE,
	VQ_AVERTED,
	VQ_COUNTDWN,
	VQ_MOVINGIN,
	VQ_ALLIED10,
	VQ_ALLIED12,
	VQ_ALLIED5,
	VQ_ALLIED6,
	VQ_ALLIED8,
	VQ_TANYA1,
	VQ_TANYA2,
	VQ_ALLY10B,
	VQ_ALLY11,
	VQ_ALLY14,
	VQ_ALLY9,
	VQ_SPY,
	VQ_TOOFAR,
	VQ_SOVIET12,
	VQ_SOVIET13,
	VQ_SOVIET9,
	VQ_BEACHEAD,
	VQ_SOVIET14,
	VQ_SIZZLE,
	VQ_SIZZLE2,
	VQ_ANTEND,
	VQ_ANTINTRO,

	//2019/11/12 JAS - Added for Retaliation movies
	VQ_RETALIATION_ALLIED1,
	VQ_RETALIATION_ALLIED2,
	VQ_RETALIATION_ALLIED3,
	VQ_RETALIATION_ALLIED4,
	VQ_RETALIATION_ALLIED5,
	VQ_RETALIATION_ALLIED6,
	VQ_RETALIATION_ALLIED7,
	VQ_RETALIATION_ALLIED8,
	VQ_RETALIATION_ALLIED9,
	VQ_RETALIATION_ALLIED10,

	VQ_RETALIATION_SOVIET1,
	VQ_RETALIATION_SOVIET2,
	VQ_RETALIATION_SOVIET3,
	VQ_RETALIATION_SOVIET4,
	VQ_RETALIATION_SOVIET5,
	VQ_RETALIATION_SOVIET6,
	VQ_RETALIATION_SOVIET7,
	VQ_RETALIATION_SOVIET8,
	VQ_RETALIATION_SOVIET9,
	VQ_RETALIATION_SOVIET10,
	VQ_RETALIATION_WINA,
	VQ_RETALIATION_WINS,
	VQ_RETALIATION_ANTS,

	VQ_COUNT,
	VQ_FIRST=0
} VQType;


/**********************************************************************
**	These enumerations are used to implement RTTI. The target system
**	uses these and thus there can be no more RTTI types than can fit
**	in the exponent of a target value.
*/
typedef enum RTTIType : unsigned char {
	RTTI_NONE=0,
	RTTI_AIRCRAFT,
	RTTI_AIRCRAFTTYPE,
	RTTI_ANIM,
	RTTI_ANIMTYPE,
	RTTI_BUILDING,
	RTTI_BUILDINGTYPE,
	RTTI_BULLET,
	RTTI_BULLETTYPE,
	RTTI_CELL,
	RTTI_FACTORY,
	RTTI_HOUSE,
	RTTI_HOUSETYPE,
	RTTI_INFANTRY,
	RTTI_INFANTRYTYPE,
	RTTI_OVERLAY,
	RTTI_OVERLAYTYPE,
	RTTI_SMUDGE,
	RTTI_SMUDGETYPE,
	RTTI_SPECIAL,
	RTTI_TEAM,
	RTTI_TEAMTYPE,
	RTTI_TEMPLATE,
	RTTI_TEMPLATETYPE,
	RTTI_TERRAIN,
	RTTI_TERRAINTYPE,
	RTTI_TRIGGER,
	RTTI_TRIGGERTYPE,
	RTTI_UNIT,
	RTTI_UNITTYPE,
	RTTI_VESSEL,
	RTTI_VESSELTYPE,

	RTTI_COUNT
} RTTIType;


/**********************************************************************
**	These are the difficulty settings of the game.
*/
typedef enum DiffType : unsigned char {
	DIFF_EASY,
	DIFF_NORMAL,
	DIFF_HARD,

	DIFF_COUNT,
	DIFF_FIRST=0
} DiffType;


/**********************************************************************
**	This is the size of the speech buffer. This value should be as large
**	as the largest speech sample, plus a few bytes for overhead
**	(16 bytes is sufficient).
*/
#define SPEECH_BUFFER_SIZE		50000L


/**********************************************************************
**	The theater mixfiles are cached into a buffer of this size. Ensure
**	that the size specified is at least as large as the largest
**	theater mixfile data block.
*/
#define THEATER_BUFFER_SIZE	1100000L


/**********************************************************************
**	This is the size of the shape buffer. This buffer is used as a staging
**	buffer for the shape drawing technology. It MUST be as big as the
**	largest shape (uncompressed) that will be drawn. If this value is
**	changed, be sure to update the makefile and rebuild all of the shape
**	data files.
*/
#define SHAPE_BUFFER_SIZE		131072L


/**********************************************************************
**	Filenames of the data files it can create at run time.
*/
#define FAME_FILE_NAME			"HALLFAME.DAT"
#define NET_SAVE_FILE_NAME		"SAVEGAME.NET"
#define CONFIG_FILE_NAME		"REDALERT.INI"


/**********************************************************************
**	Map controls. The map is composed of square elements called 'cells'.
**	All larger elements are build upon these.
*/

#define	HIGH_COORD_MASK			0x80008000L

// Size of the map in cells.
#define	MAP_CELL_W				128
#define	MAP_CELL_H				128
#define	MAP_CELL_TOTAL			(MAP_CELL_W*MAP_CELL_H)

#define	REFRESH_EOL				32767		// This number ends a refresh/occupy offset list.
#define	REFRESH_SIDEBAR		32766		// This number flags that sidebar needs refreshing.


/****************************************************************************
**	These are custom C&C specific types. The CELL is used for map coordinate
**	with cell resolution. The COORDINATE type is used for map coordinates that
**	have a lepton resolution. CELL is more efficient when indexing into the map
**	and when size is critical. COORDINATE is more efficient when dealing with
**	accuracy and object movement.
*/
typedef unsigned short	LEPTON;
typedef union {
	LEPTON Raw;
	struct {
#ifdef BIG_ENDIAN
		unsigned char Cell;
		unsigned char Lepton;
#else
		unsigned char Lepton;
		unsigned char Cell;
#endif
	} Sub;
} LEPTON_COMPOSITE;

typedef unsigned long	COORDINATE;
typedef union {
	COORDINATE Coord;
	struct {
#ifdef BIG_ENDIAN
		LEPTON_COMPOSITE Y;
		LEPTON_COMPOSITE X;
#else
		LEPTON_COMPOSITE X;
		LEPTON_COMPOSITE Y;
#endif
	} Sub;
}	COORD_COMPOSITE;

typedef signed short		CELL;
#define	SLUFF_BITS	(sizeof(CELL)*CHAR_BIT)-(14)
typedef union {
	CELL Cell;
	struct {
#ifdef BIG_ENDIAN
#if SLUFF_BITS
		/*
		**	Unused upper bits will cause problems on a big-endian machine unless they
		**	are deliberately accounted for.
		*/
		unsigned sluff:SLUF_BITS;
#endif
		unsigned Y:7;
		unsigned X:7;
#else
		unsigned X:7;
		unsigned Y:7;
#endif
	} Sub;
} CELL_COMPOSITE;

typedef int		WAYPOINT;


/**********************************************************************
**	This is the target composit information. Notice that with an RTTI_NONE
**	and an index value of 0, the target value returned is identical with
**	TARGET_NONE. This is by design and is necessary.
*/
typedef long	TARGET;

#define	TARGET_MANTISSA			24				// Bits of value precision.
#define	TARGET_EXPONENT			8
typedef union {
	TARGET Target;
	struct {
#ifdef BIG_ENDIAN
		unsigned Exponent:TARGET_EXPONENT;
		unsigned Mantissa:TARGET_MANTISSA;
#else
		unsigned Mantissa:TARGET_MANTISSA;
		unsigned Exponent:TARGET_EXPONENT;
#endif
	} Sub;
} TARGET_COMPOSITE;


inline TARGET Build_Target(RTTIType kind, int value)
{
	TARGET_COMPOSITE target;

	target.Target = 0;
	target.Sub.Exponent = kind;
	target.Sub.Mantissa = value;
	return(target.Target);
}


#define	TARGET_NONE 	((TARGET)0)


/*
**	The map is broken down into regions of this specified dimensions.
*/
#define	REGION_WIDTH		4
#define	REGION_HEIGHT		4
#define	MAP_REGION_WIDTH	(((MAP_CELL_W + (REGION_WIDTH -1)) / REGION_WIDTH)+2)
#define	MAP_REGION_HEIGHT	(((MAP_CELL_H + (REGION_WIDTH -1)) / REGION_HEIGHT)+2)
#define  MAP_TOTAL_REGIONS	(MAP_REGION_WIDTH * MAP_REGION_HEIGHT)


/**********************************************************************
**	This enumerates the various known fear states for infantry units.
**	At these stages, certain events or recovery actions are performed.
*/
typedef enum FearType : unsigned char {
	FEAR_NONE=0,			// No fear at all (default state).
	FEAR_ANXIOUS=10,		// Something makes them scared.
	FEAR_SCARED=100,		// Scared enough to take cover.
	FEAR_PANIC=200,		// Run away! Run away!
	FEAR_MAXIMUM=255		// Scared to death.
} FearType;


/**********************************************************************
**	When a moving object moves, the Per_Cell_Process function is called
**	at various times during the move. Certain operations must be
**	performed at different stages of the move. This enum specifies the
**	different conditions under which the Per_Cell_Process function is
**	called.
*/
typedef enum PCPType : unsigned char {
	PCP_ROTATION,			// When sitting in place and performing rotations.
	PCP_DURING,				// While moving between two cells.
	PCP_END,					// When the 'center' of a cell is reached during movement.
} PCPType;


/**********************************************************************
**	A base is broken up into several zones. This type enumerates the
**	various zones.
*/
typedef enum ZoneType : char {
	ZONE_CORE,			// Center of base.
	ZONE_NORTH,			// North section.
	ZONE_EAST,			// East section.
	ZONE_SOUTH,			// South section.
	ZONE_WEST,			// West section.

	ZONE_COUNT,
	ZONE_FIRST=0,
	ZONE_NONE=-1
} ZoneType;


/**********************************************************************
**	The map is prescanned to mark of movement zones according to certain
**	movement characteristics. This enum specifies those characteristics
**	and movement zones kept track of.
*/
typedef enum MZoneType : unsigned char {
	MZONE_NORMAL,				// Normal terrestrial objects (can't crush walls).
	MZONE_CRUSHER,				// Can crush crushable wall types.
	MZONE_DESTROYER,			// Can destroy walls.
	MZONE_WATER,				//	Water based objects.

	MZONE_COUNT,
	MZONE_FIRST=0
} MZoneType;

#define	MZONEF_NORMAL		(1<<MZONE_NORMAL)
#define	MZONEF_CRUSHER		(1<<MZONE_CRUSHER)
#define	MZONEF_DESTROYER	(1<<MZONE_DESTROYER)
#define	MZONEF_WATER		(1<<MZONE_WATER)
#define	MZONEF_ALL			(MZONEF_NORMAL|MZONEF_CRUSHER|MZONEF_DESTROYER|MZONEF_WATER)


/**********************************************************************
**	This records the current state of the computer controlled base. The
**	AI will respond according to this state in order to control
**	production and unit orders.
*/
typedef enum StateType : unsigned char {
	STATE_BUILDUP,			// Base is building up (defensive buildup stage).
	STATE_BROKE,			// Low on money, need cash or income source.
	STATE_THREATENED,		// Enemy units are designated to move close by.
	STATE_ATTACKED,		// Base is under direct attack.
	STATE_ENDGAME			//	Resistance is futile.
} StateType;


/**********************************************************************
**	Urgency rating used to determine what action to perform. The greater
**	the urgency the more likely the corresponding action will be chosen.
**	These values are assigned to each potential desired action the house
**	is to perform.
*/
typedef enum UrgencyType : unsigned char {
	URGENCY_NONE,				// No action on this matter is needed or desired.
	URGENCY_LOW,				// Minimal attention requested.
	URGENCY_MEDIUM,			//	Normal attention requested.
	URGENCY_HIGH,				// High attention requested.
	URGENCY_CRITICAL,			// This matter must be addressed immediately.

	URGENCY_COUNT,
	URGENCY_FIRST=URGENCY_CRITICAL
} UrgencyType;


/**********************************************************************
**	These are the various actions a house may perform. These actions refer
**	to global events that encompass selling and production. Low level house
**	specific actions of choosing targets is handled elsewhere.
*/
typedef enum StrategyType : unsigned char {
	STRATEGY_BUILD_POWER,			// Power is low, build more.
	STRATEGY_BUILD_DEFENSE,			// Defense needs boosting.
	STRATEGY_BUILD_INCOME,			// Income is low or in jeopardy, raise it.
	STRATEGY_FIRE_SALE,				// Situation hopeless, sell and attack.
	STRATEGY_BUILD_ENGINEER,		// An engineer is needed.
	STRATEGY_BUILD_OFFENSE,			// Offensive weapons are needed.
	STRATEGY_RAISE_MONEY,			// Money is low, emergency raise cash.
	STRATEGY_RAISE_POWER,			// Money is low, raise power by selling.
	STRATEGY_LOWER_POWER,			// Too much power, sell power plants.
	STRATEGY_ATTACK,					// General charge the enemy attack logic.

	STRATEGY_COUNT,
	STRATEGY_FIRST=STRATEGY_BUILD_POWER
} StrategyType;


/**********************************************************************
**	These are the various return conditions that production may
**	produce.
*/
typedef enum ProdFailType : unsigned char {
	PROD_OK,						// Production request successful.
	PROD_LIMIT,					// Failed with production capacity limit reached.
	PROD_ILLEGAL,				// Failed because of illegal request.
	PROD_CANT					// Failed because unable to comply (busy or occupied).
} ProdFailType;


/**********************************************************************
**	When performing a landing operation, the aircraft must pass through
**	navigation checkpoints. These enumerations specify the check points.
*/
typedef enum CheckPointType : unsigned char {
	CHECK_STACK,				// Holding area far away from airfield.
	CHECK_DOWNWIND,			// Downwind leg of approach.
	CHECK_CROSSWIND			// Crosswind leg of approach.
} CheckPointType;


/**********************************************************************
**	These enumerate the various crate powerups that are available.
*/
typedef enum CrateType : unsigned char {
	CRATE_MONEY,
	CRATE_UNIT,
	CRATE_PARA_BOMB,
	CRATE_HEAL_BASE,
	CRATE_CLOAK,
	CRATE_EXPLOSION,
	CRATE_NAPALM,
	CRATE_SQUAD,
	CRATE_DARKNESS,
	CRATE_REVEAL,
	CRATE_SONAR,
	CRATE_ARMOR,
	CRATE_SPEED,
	CRATE_FIREPOWER,
	CRATE_ICBM,
	CRATE_TIMEQUAKE,
	CRATE_INVULN,
	CRATE_VORTEX,

	CRATE_COUNT,
	CRATE_FIRST=0
} CrateType;


/**********************************************************************
**	These are the special weapons that can be used in the game. The common thread
**	with these weapons is that they are controlled through the sidebar
**	mechanism.
*/
typedef enum SpecialWeaponType : char {
	SPC_NONE=-1,
	SPC_SONAR_PULSE,			// Momentarily reveals submarines.
	SPC_NUCLEAR_BOMB,			//	Tactical nuclear weapon.
	SPC_CHRONOSPHERE,			// Paradox device, for teleportation
	SPC_PARA_BOMB,				// Parachute bomb delivery.
	SPC_PARA_INFANTRY,		// Parachute reinforcement delivery.
	SPC_SPY_MISSION,			// Spy plane to take photo recon mission.
	SPC_IRON_CURTAIN,			// Bestow invulnerability on a unit/building
	SPC_GPS,						// give allies free unjammable radar.

	SPC_COUNT,
	SPC_FIRST=0,
	SPC_ANY=1
} SpecialWeaponType;
#define	SPC_CHRONO2	(SPC_COUNT)


/**********************************************************************
**	The computer AI is categorized by the following enumerations. If
**	the player is controlling a house, then the IQ rating is zero. When
**	the IQ rating is at maximum, then the computer has complete control
**	of the house.
*/
//typedef enum IQType {
//	IQ_DEAD=0x0000,			// Player controlled (computer does nothing).
//	IQ_IDIOT=0x0040,
//	IQ_IMBECILE=0x0080,
//	IQ_MORON=0x00C0,
//	IQ_MENSA=0x0100			// Complete computer control -- look out!
//} IQType;


/**********************************************************************
**	These are the response values when checking to see if an object
**	can enter or exist at a specified location. By examining this
**	return value, appropriate action may be chosen.
**	NOTE: If this changes, update the static array in Find_Path module.
*/
typedef enum MoveType : unsigned char {
	MOVE_OK, 				// No blockage.
	MOVE_CLOAK,				// A cloaked blocking enemy object.
	MOVE_MOVING_BLOCK,	// Blocked, but only temporarily.
	MOVE_DESTROYABLE,		// Enemy unit or building is blocking.
	MOVE_TEMP,  			// Blocked by friendly unit.
	MOVE_NO,					// Strictly prohibited terrain.

	MOVE_COUNT
} MoveType;


/**********************************************************************
**	These are the themes that the game can play. They must be in exact
**	same order as specified in the CONQUER.TXT file as well as the filename
**	list located in the ThemeClass.
*/
typedef enum ThemeType : char {
	THEME_QUIET=-3,
	THEME_PICK_ANOTHER=-2,
	THEME_NONE=-1,
	THEME_BIGF,
	THEME_CRUS,
	THEME_FAC1,
	THEME_FAC2,
	THEME_HELL,
	THEME_RUN1,
	THEME_SMSH,
	THEME_TREN,
	THEME_WORK,
	THEME_AWAIT,
	THEME_DENSE_R,
	THEME_FOGGER1A,
	THEME_MUD1A,
	THEME_RADIO2,
	THEME_ROLLOUT,
	THEME_SNAKE,
	THEME_TERMINAT,
	THEME_TWIN,
	THEME_VECTOR1A,

	THEME_MAP,
	THEME_SCORE,
	THEME_INTRO,
	THEME_CREDITS,

	THEME_2ND_HAND,
	THEME_ARAZOID,
	THEME_BACKSTAB,
	THEME_CHAOS2,
	THEME_SHUT_IT,
	THEME_TWINMIX1,
	THEME_UNDER3,
	THEME_VR2,

#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
	THEME_BOG,
	THEME_FLOAT_V2,
	THEME_GLOOM,
	THEME_GRNDWIRE,
	THEME_RPT,
	THEME_SEARCH,
	THEME_TRACTION,
	THEME_WASTELND,
#endif

	THEME_COUNT,
	THEME_LAST=(int)THEME_COUNT-1,
	THEME_FIRST=0
} ThemeType;

//PG inline ThemeType operator++(ThemeType &, int);


/**********************************************************************
**	This is the various threat scan methods that can be used when looking
**	for targets.
*/
typedef enum ThreatType : unsigned short {
	THREAT_NORMAL=0x0000,		// Any distance threat scan?
	THREAT_RANGE=0x0001,			// Limit scan to weapon range?
	THREAT_AREA=0x0002,			// Limit scan to general area (twice weapon range)?
	THREAT_AIR=0x0004,			// Scan for air units?
	THREAT_INFANTRY=0x0008,		// Scan for infantry units?
	THREAT_VEHICLES=0x0010,		// Scan for vehicles?
	THREAT_BUILDINGS=0x0020,	// Scan for buildings?
	THREAT_TIBERIUM=0x0040,		// Limit scan to Tiberium processing objects?
	THREAT_BOATS=0x0080,			// Scan for gunboats?
	THREAT_CIVILIANS=0x0100,	// Consider civilians to be primary target?
	THREAT_CAPTURE=0x0200,		// Consider capturable buildings only?
	THREAT_FAKES=0x0400,			// Consider fake buildings a greater target?
	THREAT_POWER=0x0800,			// Consider power generating facilities a greater target?
	THREAT_FACTORIES=0x1000,	// Consider factories a greater target?
	THREAT_BASE_DEFENSE=0x2000,	// Consider base defense buildings a greater target?
} ThreatType;
//PG
//inline ThreatType operator |(ThreatType, ThreatType);
//inline ThreatType operator &(ThreatType, ThreatType);
//inline ThreatType operator ~(ThreatType);

inline ThreatType operator|(ThreatType a, ThreatType b)
{return static_cast<ThreatType>(static_cast<int>(a) | static_cast<int>(b));}

inline ThreatType operator&(ThreatType a, ThreatType b)
{return static_cast<ThreatType>(static_cast<int>(a) & static_cast<int>(b));}

inline ThreatType operator~(ThreatType a)
{return static_cast<ThreatType>(~static_cast<int>(a));}


#define THREAT_GROUND	(THREAT_VEHICLES|THREAT_BUILDINGS|THREAT_INFANTRY)


/**********************************************************************
**	These return values are used when determine if firing is legal.
**	By examining this value it can be determined what should be done
**	to fix the reason why firing wasn't allowed.
*/
typedef enum FireErrorType : unsigned char{
	FIRE_OK,				// Weapon is allowed to fire.
	FIRE_AMMO,			// No ammo available to fire?
	FIRE_FACING,		// Not correctly facing target?
	FIRE_REARM,			// It is busy rearming?
	FIRE_ROTATING,		// Is it in process of rotating?
	FIRE_ILLEGAL,		// Is it targeting something illegal?
	FIRE_CANT,			// Is this unit one that cannot fire anything?
	FIRE_MOVING,		// Is it moving and not allowed to fire while moving?
	FIRE_RANGE,			// Is the target out of range?
	FIRE_CLOAKED,		// Is the shooter currently cloaked?
	FIRE_BUSY			// Is shooter currently doing something else?
} FireErrorType;


/**********************************************************************
**	If an object can cloak, then it will be in one of these states.
**	For objects that cannot cloak, they will always be in the
**	UNCLOAKED state. This state controls how the object transitions between
**	cloaked and uncloaked conditions.
*/
typedef enum CloakType : unsigned char {
	UNCLOAKED,			// Completely visible (normal state).
	CLOAKING,			// In process of cloaking.
	CLOAKED,				// Completely cloaked (invisible).
	UNCLOAKING			// In process of uncloaking.
} CloakType;


/**********************************************************************
**	For units that are cloaking, these value specify the visual character
**	of the object.
*/
typedef enum VisualType : unsigned char{
	VISUAL_NORMAL,				// Completely visible -- normal.
	VISUAL_INDISTINCT,		// The edges shimmer and become indistinct.
	VISUAL_DARKEN,				// Color and texture is muted along with shimmering.
	VISUAL_SHADOWY,			// Body is translucent in addition to shimmering.
	VISUAL_RIPPLE,				// Just a ripple (true predator effect).
	VISUAL_HIDDEN				// Nothing at all is visible.
} VisualType;


/**********************************************************************
**	These missions enumerate the various state machines that can apply to
**	a game object. Only one of these state machines is active at any one
**	time.
*/
typedef enum MissionType : char {
	MISSION_NONE=-1,

	MISSION_SLEEP,				// Do nothing whatsoever.
	MISSION_ATTACK,			// Attack nearest enemy.
	MISSION_MOVE,				// Guard location or unit.
	MISSION_QMOVE,				// A queue list movement mission.
	MISSION_RETREAT,			// Return home for R & R.
	MISSION_GUARD,				// Stay still.
	MISSION_STICKY,			// Stay still -- never recruit.
	MISSION_ENTER,				// Move into object cooperatively.
	MISSION_CAPTURE,			//	Move into in order to capture.
	MISSION_HARVEST,			// Hunt for and collect nearby Tiberium.
	MISSION_GUARD_AREA,		// Active guard of area.
	MISSION_RETURN,			// Head back to refinery.
	MISSION_STOP,				// Sit still.
	MISSION_AMBUSH,			// Wait until discovered.
	MISSION_HUNT,				// Active search and destroy.
	MISSION_UNLOAD,			// Search for and deliver cargo.
	MISSION_SABOTAGE,			//	Move into in order to destroy.
	MISSION_CONSTRUCTION,	// Building buildup operation.
	MISSION_DECONSTRUCTION,	// Building builddown operation.
	MISSION_REPAIR,			// Repair process mission.
	MISSION_RESCUE,
	MISSION_MISSILE,
	MISSION_HARMLESS,			// Sit around and don't appear like a threat.

	MISSION_COUNT,
	MISSION_FIRST=0
} MissionType;


/**********************************************************************
**	These are the enumerated animation sequences that a building may
**	be processing. These serve to control the way that a building
**	appears.
*/
typedef enum BStateType : char {
	BSTATE_NONE=-1,
	BSTATE_CONSTRUCTION,		// Construction animation.
	BSTATE_IDLE,				// Idle animation.
	BSTATE_ACTIVE,				// Animation when building is "doing its thing".
	BSTATE_FULL,				// Special alternate active state.
	BSTATE_AUX1,				// Auxiliary animation.
	BSTATE_AUX2,				// Auxiliary animation.

	BSTATE_COUNT
} BStateType;


/**********************************************************************
**	Whenever a unit is selected and a click occurs over another object
**	or terrain element, there is some action to initiate. This specifies
**	the different types of actions possible. This also controls how the
**	mouse cursor looks when "hovering" over the spot that clicking would
**	occur at.
*/
typedef enum ActionType : unsigned char {
	ACTION_NONE,			// Either undefined action or "do nothing".
	ACTION_MOVE,			// Can move there or at least try to.
	ACTION_NOMOVE,			// Special case for movable object, but illegal mouse position.
	ACTION_ENTER,			// Special case for infantry->APC or vehicle->Repair facility.
	ACTION_SELF,			// Self select special case.
	ACTION_ATTACK,			// Can attack or fire upon it in some fashion.
	ACTION_HARVEST,		// Special harvest mode.
	ACTION_SELECT,			// Would change selection to specified object.
	ACTION_TOGGLE_SELECT,// Toggles select state of the object.
	ACTION_CAPTURE,		// The unit will try to capture the object.
	ACTION_REPAIR,			// The target object should be repaired.
	ACTION_SELL,			// The target building should be sold back.
	ACTION_SELL_UNIT,		// The target unit should be sold back.
	ACTION_NO_SELL,  		// No sell or no repair.
	ACTION_NO_REPAIR,		// No sell or no repair.
	ACTION_SABOTAGE,		// The unit will try to sabotage/destroy the object.
	ACTION_PARA_BOMB,		// Parachute bomb strike.
	ACTION_PARA_INFANTRY,// Parachute infantry strike.
	ACTION_PARA_SABOTEUR,// Parachute saboteur strike.
	ACTION_NUKE_BOMB,		// That target object should be blasted.
	ACTION_AIR_STRIKE,	// That target object should be blasted.
	ACTION_CHRONOSPHERE,	// That target object should be teleported.
	ACTION_CHRONO2,		// Teleport it to the given coordinates now.
	ACTION_IRON_CURTAIN,	// That target object should be invulnerable.
	ACTION_SPY_MISSION,	// Photo recon mission.
	ACTION_GUARD_AREA,	// Guard the area/object clicked on.
	ACTION_HEAL,			// Heal the infantryman clicked on.
	ACTION_DAMAGE,			// Enter and damage building.
	ACTION_GREPAIR,		// Enter and complete repair building.
	ACTION_NO_DEPLOY,
	ACTION_NO_ENTER,
	ACTION_NO_GREPAIR,
	ACTION_TOGGLE_PRIMARY,	// Toggle the primary status of the factory.

	ACTION_COUNT
} ActionType;


/**********************************************************************
**	When a unit gets damaged, the result of the damage is returned as
**	this type. It can range from no damage taken to complete destruction.
*/
typedef enum ResultType : unsigned char {
	RESULT_NONE,				// No damage was taken by the target.
	RESULT_LIGHT,				// Some damage was taken, but no state change occurred.
	RESULT_HALF,				// Damaged to below half strength (only returned on transition).
	RESULT_MAJOR,				// Damaged down to 1 hit point.
	RESULT_DESTROYED			// Damaged to complete destruction.
} ResultType;


#ifdef OBSOLETE
/**********************************************************************
**	These are the special concrete control defines. They enumerate the
**	sequence order of the concrete icons in the concrete art file.
*/
// DEBUG === convert this to be zero based so that a nulled cell is the
//			 	 default cell.
enum ConcreteEnum {
	C_NONE=-1,
	C_LEFT=0,
	C_RIGHT=1,
	C_RIGHT_UPDOWN=2,
	C_LEFT_UPDOWN=3,
	C_UP_RIGHT=4,
	C_UP_LEFT=5,
	C_DOWN_RIGHT=6,
	C_DOWN_LEFT=7,
	C_RIGHT_DOWN=8,
	C_LEFT_DOWN=9,
	C_RIGHT_UP=10,
	C_LEFT_UP=11,
	C_UPDOWN_RIGHT=12,
	C_UPDOWN_LEFT=13
};
#endif


/**********************************************************************
**	Units that move can move at different speeds. These enumerate the
**	different speeds that a unit can move.
*/
typedef enum MPHType : unsigned char {
	MPH_IMMOBILE=0,
	MPH_VERY_SLOW=5,				//	2
	MPH_KINDA_SLOW=6,				//	3
	MPH_SLOW=8,						//	4
	MPH_SLOW_ISH=10,				// 5
	MPH_MEDIUM_SLOW=12,			// 6
	MPH_MEDIUM=18,					// 9
	MPH_MEDIUM_FAST=30,			// 12
	MPH_MEDIUM_FASTER=35,		// 14
	MPH_FAST=40,					// 16
	MPH_ROCKET=60,					// 24
	MPH_VERY_FAST=100,			// 40
	MPH_LIGHT_SPEED=255			// 100
} MPHType;


/**********************************************************************
**	The houses that can be played are listed here. Each has their own
**	personality and strengths.
*/
typedef enum HousesType : char {
	HOUSE_NONE=-1,
	HOUSE_SPAIN,				//	Gold (unremapped)
	HOUSE_GREECE,				// LtBlue
	HOUSE_USSR,					// Red
	HOUSE_ENGLAND,				// Green
	HOUSE_UKRAINE,				// Orange
	HOUSE_GERMANY,				// Grey
	HOUSE_FRANCE,				// Blue
	HOUSE_TURKEY,				// Brown
	HOUSE_GOOD,					// Global Defense Initiative
	HOUSE_BAD,					// Brotherhood of Nod
	HOUSE_NEUTRAL,				// Civilians
	HOUSE_JP,					// Disaster Containment Team
	HOUSE_MULTI1,				// Multi-Player house #1
	HOUSE_MULTI2,				// Multi-Player house #2
	HOUSE_MULTI3,				// Multi-Player house #3
	HOUSE_MULTI4,				// Multi-Player house #4
	HOUSE_MULTI5,				// Multi-Player house #5
	HOUSE_MULTI6,				// Multi-Player house #6
	HOUSE_MULTI7,				// Multi-Player house #7
	HOUSE_MULTI8,				// Multi-Player house #8
	HOUSE_COUNT,
	HOUSE_FIRST=0
} HousesType;

//inline HousesType operator++(HousesType &, int) {return (HousesType)(int;
inline HousesType operator++(HousesType &ht) { ht = (HousesType)(((int)ht)+1); return ht; }

#define	HOUSEF_ALLIES	(HOUSEF_ENGLAND|HOUSEF_SPAIN|HOUSEF_GREECE|HOUSEF_GERMANY|HOUSEF_FRANCE|HOUSEF_TURKEY|HOUSEF_GOOD)
#define	HOUSEF_SOVIET	(HOUSEF_USSR|HOUSEF_UKRAINE|HOUSEF_BAD)
#define	HOUSEF_OTHERS	(HOUSEF_NEUTRAL|HOUSEF_JP|HOUSEF_MULTI1|HOUSEF_MULTI2|HOUSEF_MULTI3|HOUSEF_MULTI4|HOUSEF_MULTI5|HOUSEF_MULTI6|HOUSEF_MULTI7|HOUSEF_MULTI8)
#define	HOUSEF_NONE		0

#define	HOUSEF_ENGLAND	(1L<<HOUSE_ENGLAND)
#define	HOUSEF_SPAIN	(1L<<HOUSE_SPAIN)
#define	HOUSEF_GREECE	(1L<<HOUSE_GREECE)
#define	HOUSEF_USSR		(1L<<HOUSE_USSR)
#define	HOUSEF_UKRAINE	(1L<<HOUSE_UKRAINE)
#define	HOUSEF_GERMANY	(1L<<HOUSE_GERMANY)
#define	HOUSEF_FRANCE	(1L<<HOUSE_FRANCE)
#define	HOUSEF_TURKEY	(1L<<HOUSE_TURKEY)
#define	HOUSEF_GOOD		(1L<<HOUSE_GOOD)
#define	HOUSEF_BAD		(1L<<HOUSE_BAD)
#define	HOUSEF_NEUTRAL	(1L<<HOUSE_NEUTRAL)
#define	HOUSEF_JP		(1L<<HOUSE_JP)
#define	HOUSEF_MULTI1	(1L<<HOUSE_MULTI1)
#define	HOUSEF_MULTI2	(1L<<HOUSE_MULTI2)
#define	HOUSEF_MULTI3	(1L<<HOUSE_MULTI3)
#define	HOUSEF_MULTI4	(1L<<HOUSE_MULTI4)
#define	HOUSEF_MULTI5	(1L<<HOUSE_MULTI5)
#define	HOUSEF_MULTI6	(1L<<HOUSE_MULTI6)
#define	HOUSEF_MULTI7	(1L<<HOUSE_MULTI7)
#define	HOUSEF_MULTI8	(1L<<HOUSE_MULTI8)

typedef enum PlayerColorType : char {
	PCOLOR_NONE = -1,
	PCOLOR_GOLD,
	PCOLOR_LTBLUE,
	PCOLOR_RED,
	PCOLOR_GREEN,
	PCOLOR_ORANGE,
	PCOLOR_BLUE,		//This is actually the red scheme used in the dialogs
	PCOLOR_GREY,
	PCOLOR_BROWN,
	PCOLOR_TYPE,
	PCOLOR_REALLY_BLUE,
	PCOLOR_DIALOG_BLUE,

	PCOLOR_COUNT,
	PCOLOR_FIRST=0,
	PCOLOR_LAST=PCOLOR_COUNT-1
} PlayerColorType;


/**********************************************************************
**	This enumerates the remap logic to be applied to an object type when
**	it appears in the construction sidebar.
*/
typedef enum RemapType : unsigned char {
	REMAP_NONE,
	REMAP_NORMAL,
	REMAP_ALTERNATE
} RemapType;


/**********************************************************************
** These are the types of games that can be played.  GDI & NOD are the
** usual human-vs-computer games; 2-Player games are network or modem,
** with 2 players; multi-player games are network with > 2 players.
*/
typedef enum ScenarioPlayerEnum : char
{
	SCEN_PLAYER_NONE = -1,
	SCEN_PLAYER_SPAIN,
	SCEN_PLAYER_GREECE,
	SCEN_PLAYER_USSR,
	SCEN_PLAYER_JP,
	SCEN_PLAYER_2PLAYER,
	SCEN_PLAYER_MPLAYER,
	SCEN_PLAYER_COUNT,
	SCEN_PLAYER_FIRST = 0
} ScenarioPlayerType;

inline ScenarioPlayerType operator++(ScenarioPlayerType &, int);


/**********************************************************************
** These are the directional parameters for a scenario.
*/
typedef enum ScenarioDirEnum : char 
{
	SCEN_DIR_NONE = -1,
	SCEN_DIR_EAST,
	SCEN_DIR_WEST,
	SCEN_DIR_COUNT,
	SCEN_DIR_FIRST = 0
} ScenarioDirType;

inline ScenarioDirType operator++(ScenarioDirType &, int);


/**********************************************************************
** These are the random variations of a scenario.
*/
typedef enum ScenarioVarEnum : char 
{
	SCEN_VAR_NONE = -1,
	SCEN_VAR_A,
	SCEN_VAR_B,
	SCEN_VAR_C,
	SCEN_VAR_D,
	SCEN_VAR_COUNT,		// comes before the Lose value!
	SCEN_VAR_LOSE,
	SCEN_VAR_FIRST = 0
} ScenarioVarType;

//inline ScenarioVarType operator++(ScenarioVarType &, int);
inline ScenarioVarType operator++(ScenarioVarType &n) { n = (ScenarioVarType)(((int)n) + 1); return n; }


/**********************************************************************
**	The objects to be drawn on the map are grouped into layers. These
**	enumerated values specify those layers. The ground layer is sorted
**	from back to front.
*/
typedef enum LayerType : char {
	LAYER_NONE=-1,
	LAYER_SURFACE,		// Flat on the ground (no sorting or apparent vertical height).
	LAYER_GROUND,		// Touching the ground type object (units & buildings).
	LAYER_AIR,			// Flying above the ground (explosions & flames).
	LAYER_TOP,			// Topmost layer (aircraft & bullets).

	LAYER_COUNT,
	LAYER_FIRST=0
} LayerType;

//PG inline LayerType operator++(LayerType &, int);
inline LayerType operator++(LayerType &n) { n = (LayerType)(((int)n) + 1); return n; }


/**********************************************************************
**	This enumerates the various bullet types. These types specify bullet's
**	visual and explosive characteristics.
*/
typedef enum BulletType : char {
	BULLET_NONE=-1,

	BULLET_INVISIBLE,
	BULLET_CANNON,
	BULLET_ACK,
	BULLET_TORPEDO,
	BULLET_FROG,
	BULLET_HEAT_SEEKER,
	BULLET_LASER_GUIDED,
	BULLET_LOBBED,
	BULLET_BOMBLET,
	BULLET_BALLISTIC,
	BULLET_PARACHUTE,
	BULLET_FIREBALL,
	BULLET_DOG,
	BULLET_CATAPULT,
	BULLET_AAMISSILE,
	BULLET_GPS_SATELLITE,
	BULLET_NUKE_UP,
	BULLET_NUKE_DOWN,

	BULLET_COUNT,
	BULLET_FIRST=0
} BulletType;

//PG inline BulletType operator++(BulletType &, int);
inline BulletType operator++(BulletType &n) { n = (BulletType)(((int)n) + 1); return n; }


/**********************************************************************
**	All game buildings (structures) are enumerated here. This includes
**	civilian structures as well.
*/
typedef enum StructType : char {
	STRUCT_NONE=-1,
	STRUCT_ADVANCED_TECH,
	STRUCT_IRON_CURTAIN,
	STRUCT_WEAP,
	STRUCT_CHRONOSPHERE,
	STRUCT_PILLBOX,
	STRUCT_CAMOPILLBOX,
	STRUCT_RADAR,
	STRUCT_GAP,
	STRUCT_TURRET,
	STRUCT_AAGUN,
	STRUCT_FLAME_TURRET,
	STRUCT_CONST,
	STRUCT_REFINERY,
	STRUCT_STORAGE,
	STRUCT_HELIPAD,
	STRUCT_SAM,
	STRUCT_AIRSTRIP,
	STRUCT_POWER,
	STRUCT_ADVANCED_POWER,
	STRUCT_SOVIET_TECH,
	STRUCT_HOSPITAL,
	STRUCT_BARRACKS,
	STRUCT_TENT,
	STRUCT_KENNEL,
	STRUCT_REPAIR,
	STRUCT_BIO_LAB,
	STRUCT_MISSION,
	STRUCT_SHIP_YARD,
	STRUCT_SUB_PEN,
	STRUCT_MSLO,
	STRUCT_FORWARD_COM,
	STRUCT_TESLA,

	/*
	**	All buildings that are never used as a prerequisite
	**	for construction, follow this point. Typically, this is
	**	limited to civilian structures. Also, the following
	**	buildings are NEVER used in the availability bit field
	**	record that each house maintains. i.e., STRUCTF_????
	**	bit checking will never occur with the following
	**	building types.
	*/
	STRUCT_FAKEWEAP,
	STRUCT_FAKECONST,
	STRUCT_FAKE_YARD,
	STRUCT_FAKE_PEN,
	STRUCT_FAKE_RADAR,

	STRUCT_SANDBAG_WALL,
	STRUCT_CYCLONE_WALL,
	STRUCT_BRICK_WALL,
	STRUCT_BARBWIRE_WALL,
	STRUCT_WOOD_WALL,
	STRUCT_FENCE,

	STRUCT_AVMINE,
	STRUCT_APMINE,
	STRUCT_V01,
	STRUCT_V02,
	STRUCT_V03,
	STRUCT_V04,
	STRUCT_V05,
	STRUCT_V06,
	STRUCT_V07,
	STRUCT_V08,
	STRUCT_V09,
	STRUCT_V10,
	STRUCT_V11,
	STRUCT_V12,
	STRUCT_V13,
	STRUCT_V14,
	STRUCT_V15,
	STRUCT_V16,
	STRUCT_V17,
	STRUCT_V18,
	STRUCT_PUMP,
	STRUCT_V20,
	STRUCT_V21,
	STRUCT_V22,
	STRUCT_V23,
	STRUCT_V24,
	STRUCT_V25,
	STRUCT_V26,
	STRUCT_V27,
	STRUCT_V28,
	STRUCT_V29,
	STRUCT_V30,
	STRUCT_V31,
	STRUCT_V32,
	STRUCT_V33,
	STRUCT_V34,
	STRUCT_V35,
	STRUCT_V36,
	STRUCT_V37,
	STRUCT_BARREL,
	STRUCT_BARREL3,

#ifdef FIXIT_ANTS
	STRUCT_QUEEN,
	STRUCT_LARVA1,
	STRUCT_LARVA2,
#endif

	STRUCT_COUNT,
	STRUCT_FIRST=0
} StructType;

//PG inline StructType operator++(StructType &, int);
inline StructType operator++(StructType &n) { n = (StructType)(((int)n) + 1); return n; }

#define	STRUCTF_NONE				0L
#define	STRUCTF_ADVANCED_TECH	(1L << STRUCT_ADVANCED_TECH)
#define	STRUCTF_IRON_CURTAIN		(1L << STRUCT_IRON_CURTAIN)
#define	STRUCTF_WEAP				(1L << STRUCT_WEAP)
#define	STRUCTF_CHRONOSPHERE		(1L << STRUCT_CHRONOSPHERE)
#define	STRUCTF_PILLBOX			(1L << STRUCT_PILLBOX)
#define	STRUCTF_CAMOPILLBOX		(1L << STRUCT_CAMOPILLBOX)
#define	STRUCTF_RADAR				(1L << STRUCT_RADAR)
#define	STRUCTF_GAP					(1L << STRUCT_GAP)
#define	STRUCTF_TURRET				(1L << STRUCT_TURRET)
#define	STRUCTF_AAGUN				(1L << STRUCT_AAGUN)
#define	STRUCTF_FLAME_TURRET		(1L << STRUCT_FLAME_TURRET)
#define	STRUCTF_CONST				(1L << STRUCT_CONST)
#define	STRUCTF_REFINERY			(1L << STRUCT_REFINERY)
#define	STRUCTF_STORAGE			(1L << STRUCT_STORAGE)
#define	STRUCTF_HELIPAD			(1L << STRUCT_HELIPAD)
#define	STRUCTF_SAM					(1L << STRUCT_SAM)
#define	STRUCTF_AIRSTRIP			(1L << STRUCT_AIRSTRIP)
#define	STRUCTF_POWER				(1L << STRUCT_POWER)
#define	STRUCTF_ADVANCED_POWER	(1L << STRUCT_ADVANCED_POWER)
#define	STRUCTF_SOVIET_TECH		(1L << STRUCT_SOVIET_TECH)
#define	STRUCTF_HOSPITAL			(1L << STRUCT_HOSPITAL)
#define	STRUCTF_BARRACKS			(1L << STRUCT_BARRACKS)
#define	STRUCTF_TENT				(1L << STRUCT_TENT)
#define	STRUCTF_KENNEL				(1L << STRUCT_KENNEL)
#define	STRUCTF_REPAIR				(1L << STRUCT_REPAIR)
#define	STRUCTF_BIO_LAB			(1L << STRUCT_BIO_LAB)
#define	STRUCTF_MISSION			(1L << STRUCT_MISSION)
#define	STRUCTF_SHIP_YARD			(1L << STRUCT_SHIP_YARD)
#define	STRUCTF_SUB_PEN			(1L << STRUCT_SUB_PEN)
#define	STRUCTF_MSLO				(1L << STRUCT_MSLO)
#define	STRUCTF_FAKECONST			(1L << STRUCT_FAKECONST)
#define	STRUCTF_FAKEWEAP			(1L << STRUCT_FAKEWEAP)


/**********************************************************************
**	The overlays are enumerated here. An overlay functions similarly to
**	a transparent icon. It is placed over the terrain but usually falls
**	"under" buildings, trees, and units.
*/
typedef enum OverlayType : char {
	OVERLAY_NONE=-1,
	OVERLAY_SANDBAG_WALL,	// Piled sandbags.
	OVERLAY_CYCLONE_WALL,	// Chain-link fence.
	OVERLAY_BRICK_WALL,		// Solid concrete wall.
	OVERLAY_BARBWIRE_WALL,	// Barbed-wire wall.
	OVERLAY_WOOD_WALL,		// Wooden fence.
	OVERLAY_GOLD1,
	OVERLAY_GOLD2,
	OVERLAY_GOLD3,
	OVERLAY_GOLD4,
	OVERLAY_GEMS1,
	OVERLAY_GEMS2,
	OVERLAY_GEMS3,
	OVERLAY_GEMS4,
	OVERLAY_V12,				// Haystacks
	OVERLAY_V13,				// Haystack
	OVERLAY_V14,				// Wheat field
	OVERLAY_V15,				// Fallow field
	OVERLAY_V16,				//	Corn field
	OVERLAY_V17,				// Celery field
	OVERLAY_V18,				// Potato field
	OVERLAY_FLAG_SPOT,		// Flag start location.
	OVERLAY_WOOD_CRATE,		// Wooden goodie crate.
	OVERLAY_STEEL_CRATE,		//	Steel goodie crate.
	OVERLAY_FENCE,				// New fangled fence.
	OVERLAY_WATER_CRATE,		//	Water goodie crate.

	OVERLAY_COUNT,
	OVERLAY_FIRST=0
} OverlayType;

//PG inline OverlayType operator++(OverlayType &, int);


/**********************************************************************
**	This specifies the infantry in the game. The "E" designation is
**	similar to the army classification of enlisted soldiers.
*/
typedef enum InfantryType : char {
	INFANTRY_NONE=-1,
	INFANTRY_E1,				// Mini-gun armed.
	INFANTRY_E2,				// Grenade thrower.
	INFANTRY_E3,				// Rocket launcher.
	INFANTRY_E4,				// Flame thrower equipped.
	INFANTRY_RENOVATOR,		// Engineer.
	INFANTRY_TANYA,			// Saboteur.
	INFANTRY_SPY,				// Spy.
	INFANTRY_THIEF,			// Thief.
	INFANTRY_MEDIC,			// Field Medic.
	INFANTRY_GENERAL,			// Field Marshal.
	INFANTRY_DOG,				// Soviet attack dog

	INFANTRY_C1,				// Civilian
	INFANTRY_C2,				// Civilian
	INFANTRY_C3,				// Civilian
	INFANTRY_C4,				// Civilian
	INFANTRY_C5,				// Civilian
	INFANTRY_C6,				// Civilian
	INFANTRY_C7,				// Civilian
	INFANTRY_C8,				// Civilian
	INFANTRY_C9,				// Civilian
	INFANTRY_C10,				// Nikumba
	INFANTRY_EINSTEIN,		// Einstein
	INFANTRY_DELPHI,			// Agent "Delphi"
	INFANTRY_CHAN,				// Dr. Chan

#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
// CounterStrike II only!
	INFANTRY_SHOCK,			// Shock Trooper
	INFANTRY_MECHANIC,
#endif

	INFANTRY_COUNT,
	INFANTRY_FIRST=0
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
,
	INFANTRY_RA_COUNT = INFANTRY_SHOCK
#endif
} InfantryType;

#define INFANTRYF_DOG	(1L << INFANTRY_DOG)

//PG inline InfantryType operator++(InfantryType &, int);


/**********************************************************************
**	The game units are enumerated here. These include not only traditional
**	vehicles, but also hovercraft and gunboats.
*/
typedef enum UnitType : char {
	UNIT_NONE=-1,
	UNIT_HTANK,					// Mammoth tank.
	UNIT_MTANK,					// Heavy tank.
	UNIT_MTANK2,				// Medium tank.
	UNIT_LTANK,					// Light tank ('Bradly').
	UNIT_APC,					// APC.
	UNIT_MINELAYER,			// Mine-laying vehicle.
	UNIT_JEEP,					// 4x4 jeep replacement.
	UNIT_HARVESTER,			// Resource gathering vehicle.
	UNIT_ARTY,					// Artillery unit.
	UNIT_MRJ,					// Mobile Radar Jammer.
	UNIT_MGG,					// Mobile Gap Generator
	UNIT_MCV,					// Mobile construction vehicle.
	UNIT_V2_LAUNCHER,			// V2 rocket launcher.
	UNIT_TRUCK,					// Convoy truck

#ifdef FIXIT_ANTS
	UNIT_ANT1,					// Warrior ant.
	UNIT_ANT2,					// Warrior ant.
	UNIT_ANT3,					// Warrior ant.
#endif

#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
// CS II ONLY!
	UNIT_CHRONOTANK,			// Chrono-shifting tank
	UNIT_TESLATANK,			// Tesla-equipped tank
	UNIT_MAD,					// Timequake tank
	UNIT_DEMOTRUCK,			// Jihad truck
#ifdef FIXIT_PHASETRANSPORT	//	checked - ajw 9/28/98
	UNIT_PHASE,					// cloaking APC for special missions
#endif
#endif

	UNIT_COUNT,
	UNIT_FIRST=0
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
,
	UNIT_RA_COUNT = UNIT_CHRONOTANK
#endif
} UnitType;

//PG inline UnitType operator++(UnitType &, int);

#define	UNITF_HTANK			(1L<<UNIT_HTANK)
#define	UNITF_MTANK			(1L<<UNIT_MTANK)
#define	UNITF_MTANK2		(1L<<UNIT_MTANK2)
#define	UNITF_LTANK			(1L<<UNIT_LTANK)
#define	UNITF_STANK			(1L<<UNIT_STANK)
#define	UNITF_APC			(1L<<UNIT_APC)
#define	UNITF_MLRS			(1L<<UNIT_MLRS)
#define	UNITF_JEEP			(1L<<UNIT_JEEP)
#define	UNITF_HARVESTER	(1L<<UNIT_HARVESTER)
#define	UNITF_ARTY			(1L<<UNIT_ARTY)
#define	UNITF_MCV			(1L<<UNIT_MCV)


/**********************************************************************
**	The naval vessels are enumerated below.
*/
typedef enum VesselType : char {
	VESSEL_NONE=-1,

	VESSEL_SS,						// Submarine
	VESSEL_DD,						// Medium weapon patrol craft
	VESSEL_CA,						// Heavy weapon patrol craft
	VESSEL_TRANSPORT,				// Unit transporter
	VESSEL_PT,						// Light weapon patrol craft
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
// CS II ONLY
	VESSEL_MISSILESUB,			// Missile-equipped submarine
#endif
#ifdef FIXIT_CARRIER	//	checked - ajw 9/28/98
	VESSEL_CARRIER,
#endif

	VESSEL_COUNT,
	VESSEL_FIRST=0
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
,
	VESSEL_RA_COUNT = VESSEL_MISSILESUB
#endif
} VesselType;

//inline VesselType operator++(VesselType &, int);

#define	VESSELF_SS			(1L<<VESSEL_SS)
#define	VESSELF_DD			(1L<<VESSEL_DD)
#define	VESSELF_CA			(1L<<VESSEL_CA)
#define	VESSELF_TRANSPORT	(1L<<VESSEL_TRANSPORT)
#define	VESSELF_PT			(1L<<VESSEL_PT)


/**********************************************************************
**	The various aircraft types are enumerated here. These include helicopters
**	as well as traditional aircraft.
*/
typedef enum AircraftType : char {
	AIRCRAFT_TRANSPORT,			// Transport helicopter.
	AIRCRAFT_BADGER,				// Badger bomber.
	AIRCRAFT_U2,					// Photo recon plane.
	AIRCRAFT_MIG,					// Mig attack plane.
	AIRCRAFT_YAK,					// Yak attack plane.
	AIRCRAFT_LONGBOW,				// Apache gunship.
	AIRCRAFT_HIND,					// Soviet attach helicopter.

	AIRCRAFT_COUNT,
	AIRCRAFT_NONE=-1,
	AIRCRAFT_FIRST=0
} AircraftType;

#define	AIRCRAFTF_TRANSPORT	(1L << AIRCRAFT_TRANSPORT)
#define	AIRCRAFTF_BADGER		(1L << AIRCRAFT_BADGER)
#define	AIRCRAFTF_U2			(1L << AIRCRAFT_U2)
#define	AIRCRAFTF_MIG			(1L << AIRCRAFT_MIG)
#define	AIRCRAFTF_YAK			(1L << AIRCRAFT_YAK)
#define	AIRCRAFTF_LONGBOW		(1L << AIRCRAFT_LONGBOW)
#define	AIRCRAFTF_HIND			(1L << AIRCRAFT_HIND)

//PG inline AircraftType operator++(AircraftType &, int);


/**********************************************************************
**	The game templates are enumerated here. These are the underlying
**	terrain art. This includes everything from water to cliffs. If the
**	terrain is broken up into icons, is not transparent, and is drawn
**	as the bottom most layer, then it is a template.
*/
typedef enum TemplateType : unsigned short {
	TEMPLATE_CLEAR1,
	TEMPLATE_WATER,			// This must be the first non-clear template.
	TEMPLATE_WATER2,
	TEMPLATE_SHORE01,
	TEMPLATE_SHORE02,
	TEMPLATE_SHORE03,
	TEMPLATE_SHORE04,
	TEMPLATE_SHORE05,
	TEMPLATE_SHORE06,
	TEMPLATE_SHORE07,
	TEMPLATE_SHORE08,
	TEMPLATE_SHORE09,
	TEMPLATE_SHORE10,
	TEMPLATE_SHORE11,
	TEMPLATE_SHORE12,
	TEMPLATE_SHORE13,
	TEMPLATE_SHORE14,
	TEMPLATE_SHORE15,
	TEMPLATE_SHORE16,
	TEMPLATE_SHORE17,
	TEMPLATE_SHORE18,
	TEMPLATE_SHORE19,
	TEMPLATE_SHORE20,
	TEMPLATE_SHORE21,
	TEMPLATE_SHORE22,
	TEMPLATE_SHORE23,
	TEMPLATE_SHORE24,
	TEMPLATE_SHORE25,
	TEMPLATE_SHORE26,
	TEMPLATE_SHORE27,
	TEMPLATE_SHORE28,
	TEMPLATE_SHORE29,
	TEMPLATE_SHORE30,
	TEMPLATE_SHORE31,
	TEMPLATE_SHORE32,
	TEMPLATE_SHORE33,
	TEMPLATE_SHORE34,
	TEMPLATE_SHORE35,
	TEMPLATE_SHORE36,
	TEMPLATE_SHORE37,
	TEMPLATE_SHORE38,
	TEMPLATE_SHORE39,
	TEMPLATE_SHORE40,
	TEMPLATE_SHORE41,
	TEMPLATE_SHORE42,
	TEMPLATE_SHORE43,
	TEMPLATE_SHORE44,
	TEMPLATE_SHORE45,
	TEMPLATE_SHORE46,
	TEMPLATE_SHORE47,
	TEMPLATE_SHORE48,
	TEMPLATE_SHORE49,
	TEMPLATE_SHORE50,
	TEMPLATE_SHORE51,
	TEMPLATE_SHORE52,
	TEMPLATE_SHORE53,
	TEMPLATE_SHORE54,
	TEMPLATE_SHORE55,
	TEMPLATE_SHORE56,
	TEMPLATE_SHORECLIFF01,
	TEMPLATE_SHORECLIFF02,
	TEMPLATE_SHORECLIFF03,
	TEMPLATE_SHORECLIFF04,
	TEMPLATE_SHORECLIFF05,
	TEMPLATE_SHORECLIFF06,
	TEMPLATE_SHORECLIFF07,
	TEMPLATE_SHORECLIFF08,
	TEMPLATE_SHORECLIFF09,
	TEMPLATE_SHORECLIFF10,
	TEMPLATE_SHORECLIFF11,
	TEMPLATE_SHORECLIFF12,
	TEMPLATE_SHORECLIFF13,
	TEMPLATE_SHORECLIFF14,
	TEMPLATE_SHORECLIFF15,
	TEMPLATE_SHORECLIFF16,
	TEMPLATE_SHORECLIFF17,
	TEMPLATE_SHORECLIFF18,
	TEMPLATE_SHORECLIFF19,
	TEMPLATE_SHORECLIFF20,
	TEMPLATE_SHORECLIFF21,
	TEMPLATE_SHORECLIFF22,
	TEMPLATE_SHORECLIFF23,
	TEMPLATE_SHORECLIFF24,
	TEMPLATE_SHORECLIFF25,
	TEMPLATE_SHORECLIFF26,
	TEMPLATE_SHORECLIFF27,
	TEMPLATE_SHORECLIFF28,
	TEMPLATE_SHORECLIFF29,
	TEMPLATE_SHORECLIFF30,
	TEMPLATE_SHORECLIFF31,
	TEMPLATE_SHORECLIFF32,
	TEMPLATE_SHORECLIFF33,
	TEMPLATE_SHORECLIFF34,
	TEMPLATE_SHORECLIFF35,
	TEMPLATE_SHORECLIFF36,
	TEMPLATE_SHORECLIFF37,
	TEMPLATE_SHORECLIFF38,
	TEMPLATE_BOULDER1,
	TEMPLATE_BOULDER2,
	TEMPLATE_BOULDER3,
	TEMPLATE_BOULDER4,
	TEMPLATE_BOULDER5,
	TEMPLATE_BOULDER6,
	TEMPLATE_PATCH01,
	TEMPLATE_PATCH02,
	TEMPLATE_PATCH03,
	TEMPLATE_PATCH04,
	TEMPLATE_PATCH07,
	TEMPLATE_PATCH08,
	TEMPLATE_PATCH13,
	TEMPLATE_PATCH14,
	TEMPLATE_PATCH15,
	TEMPLATE_RIVER01,
	TEMPLATE_RIVER02,
	TEMPLATE_RIVER03,
	TEMPLATE_RIVER04,
	TEMPLATE_RIVER05,
	TEMPLATE_RIVER06,
	TEMPLATE_RIVER07,
	TEMPLATE_RIVER08,
	TEMPLATE_RIVER09,
	TEMPLATE_RIVER10,
	TEMPLATE_RIVER11,
	TEMPLATE_RIVER12,
	TEMPLATE_RIVER13,
	TEMPLATE_FALLS1,
	TEMPLATE_FALLS1A,
	TEMPLATE_FALLS2,
	TEMPLATE_FALLS2A,
	TEMPLATE_FORD1,
	TEMPLATE_FORD2,
	TEMPLATE_BRIDGE1,
	TEMPLATE_BRIDGE1D,
	TEMPLATE_BRIDGE2,
	TEMPLATE_BRIDGE2D,
	TEMPLATE_SLOPE01,
	TEMPLATE_SLOPE02,
	TEMPLATE_SLOPE03,
	TEMPLATE_SLOPE04,
	TEMPLATE_SLOPE05,
	TEMPLATE_SLOPE06,
	TEMPLATE_SLOPE07,
	TEMPLATE_SLOPE08,
	TEMPLATE_SLOPE09,
	TEMPLATE_SLOPE10,
	TEMPLATE_SLOPE11,
	TEMPLATE_SLOPE12,
	TEMPLATE_SLOPE13,
	TEMPLATE_SLOPE14,
	TEMPLATE_SLOPE15,
	TEMPLATE_SLOPE16,
	TEMPLATE_SLOPE17,
	TEMPLATE_SLOPE18,
	TEMPLATE_SLOPE19,
	TEMPLATE_SLOPE20,
	TEMPLATE_SLOPE21,
	TEMPLATE_SLOPE22,
	TEMPLATE_SLOPE23,
	TEMPLATE_SLOPE24,
	TEMPLATE_SLOPE25,
	TEMPLATE_SLOPE26,
	TEMPLATE_SLOPE27,
	TEMPLATE_SLOPE28,
	TEMPLATE_SLOPE29,
	TEMPLATE_SLOPE30,
	TEMPLATE_SLOPE31,
	TEMPLATE_SLOPE32,
	TEMPLATE_SLOPE33,
	TEMPLATE_SLOPE34,
	TEMPLATE_SLOPE35,
	TEMPLATE_SLOPE36,
	TEMPLATE_SLOPE37,
	TEMPLATE_SLOPE38,
	TEMPLATE_ROAD01,
	TEMPLATE_ROAD02,
	TEMPLATE_ROAD03,
	TEMPLATE_ROAD04,
	TEMPLATE_ROAD05,
	TEMPLATE_ROAD06,
	TEMPLATE_ROAD07,
	TEMPLATE_ROAD08,
	TEMPLATE_ROAD09,
	TEMPLATE_ROAD10,
	TEMPLATE_ROAD11,
	TEMPLATE_ROAD12,
	TEMPLATE_ROAD13,
	TEMPLATE_ROAD14,
	TEMPLATE_ROAD15,
	TEMPLATE_ROAD16,
	TEMPLATE_ROAD17,
	TEMPLATE_ROAD18,
	TEMPLATE_ROAD19,
	TEMPLATE_ROAD20,
	TEMPLATE_ROAD21,
	TEMPLATE_ROAD22,
	TEMPLATE_ROAD23,
	TEMPLATE_ROAD24,
	TEMPLATE_ROAD25,
	TEMPLATE_ROAD26,
	TEMPLATE_ROAD27,
	TEMPLATE_ROAD28,
	TEMPLATE_ROAD29,
	TEMPLATE_ROAD30,
	TEMPLATE_ROAD31,
	TEMPLATE_ROAD32,
	TEMPLATE_ROAD33,
	TEMPLATE_ROAD34,
	TEMPLATE_ROAD35,
	TEMPLATE_ROAD36,
	TEMPLATE_ROAD37,
	TEMPLATE_ROAD38,
	TEMPLATE_ROAD39,
	TEMPLATE_ROAD40,
	TEMPLATE_ROAD41,
	TEMPLATE_ROAD42,
	TEMPLATE_ROAD43,
	TEMPLATE_ROUGH01,
	TEMPLATE_ROUGH02,
	TEMPLATE_ROUGH03,
	TEMPLATE_ROUGH04,
	TEMPLATE_ROUGH05,
	TEMPLATE_ROUGH06,
	TEMPLATE_ROUGH07,
	TEMPLATE_ROUGH08,
	TEMPLATE_ROUGH09,
	TEMPLATE_ROUGH10,
	TEMPLATE_ROUGH11,
	TEMPLATE_ROAD44,
	TEMPLATE_ROAD45,
	TEMPLATE_RIVER14,
	TEMPLATE_RIVER15,
	TEMPLATE_RIVERCLIFF01,
	TEMPLATE_RIVERCLIFF02,
	TEMPLATE_RIVERCLIFF03,
	TEMPLATE_RIVERCLIFF04,
	TEMPLATE_BRIDGE_1A,
	TEMPLATE_BRIDGE_1B,
	TEMPLATE_BRIDGE_1C,
	TEMPLATE_BRIDGE_2A,
	TEMPLATE_BRIDGE_2B,
	TEMPLATE_BRIDGE_2C,
	TEMPLATE_BRIDGE_3A,
	TEMPLATE_BRIDGE_3B,
	TEMPLATE_BRIDGE_3C,
	TEMPLATE_BRIDGE_3D,
	TEMPLATE_BRIDGE_3E,
	TEMPLATE_BRIDGE_3F,
	TEMPLATE_F01,
	TEMPLATE_F02,
	TEMPLATE_F03,
	TEMPLATE_F04,
	TEMPLATE_F05,
	TEMPLATE_F06,

	// Custom interior pieces.
	TEMPLATE_ARRO0001,
	TEMPLATE_ARRO0002,
	TEMPLATE_ARRO0003,
	TEMPLATE_ARRO0004,
	TEMPLATE_ARRO0005,
	TEMPLATE_ARRO0006,
	TEMPLATE_ARRO0007,
	TEMPLATE_ARRO0008,
	TEMPLATE_ARRO0009,
	TEMPLATE_ARRO0010,
	TEMPLATE_ARRO0011,
	TEMPLATE_ARRO0012,
	TEMPLATE_ARRO0013,
	TEMPLATE_ARRO0014,
	TEMPLATE_ARRO0015,
	TEMPLATE_FLOR0001,
	TEMPLATE_FLOR0002,
	TEMPLATE_FLOR0003,
	TEMPLATE_FLOR0004,
	TEMPLATE_FLOR0005,
	TEMPLATE_FLOR0006,
	TEMPLATE_FLOR0007,
	TEMPLATE_GFLR0001,
	TEMPLATE_GFLR0002,
	TEMPLATE_GFLR0003,
	TEMPLATE_GFLR0004,
	TEMPLATE_GFLR0005,
	TEMPLATE_GSTR0001,
	TEMPLATE_GSTR0002,
	TEMPLATE_GSTR0003,
	TEMPLATE_GSTR0004,
	TEMPLATE_GSTR0005,
	TEMPLATE_GSTR0006,
	TEMPLATE_GSTR0007,
	TEMPLATE_GSTR0008,
	TEMPLATE_GSTR0009,
	TEMPLATE_GSTR0010,
	TEMPLATE_GSTR0011,
	TEMPLATE_LWAL0001,
	TEMPLATE_LWAL0002,
	TEMPLATE_LWAL0003,
	TEMPLATE_LWAL0004,
	TEMPLATE_LWAL0005,
	TEMPLATE_LWAL0006,
	TEMPLATE_LWAL0007,
	TEMPLATE_LWAL0008,
	TEMPLATE_LWAL0009,
	TEMPLATE_LWAL0010,
	TEMPLATE_LWAL0011,
	TEMPLATE_LWAL0012,
	TEMPLATE_LWAL0013,
	TEMPLATE_LWAL0014,
	TEMPLATE_LWAL0015,
	TEMPLATE_LWAL0016,
	TEMPLATE_LWAL0017,
	TEMPLATE_LWAL0018,
	TEMPLATE_LWAL0019,
	TEMPLATE_LWAL0020,
	TEMPLATE_LWAL0021,
	TEMPLATE_LWAL0022,
	TEMPLATE_LWAL0023,
	TEMPLATE_LWAL0024,
	TEMPLATE_LWAL0025,
	TEMPLATE_LWAL0026,
	TEMPLATE_LWAL0027,
	TEMPLATE_STRP0001,
	TEMPLATE_STRP0002,
	TEMPLATE_STRP0003,
	TEMPLATE_STRP0004,
	TEMPLATE_STRP0005,
	TEMPLATE_STRP0006,
	TEMPLATE_STRP0007,
	TEMPLATE_STRP0008,
	TEMPLATE_STRP0009,
	TEMPLATE_STRP0010,
	TEMPLATE_STRP0011,
	TEMPLATE_WALL0001,
	TEMPLATE_WALL0002,
	TEMPLATE_WALL0003,
	TEMPLATE_WALL0004,
	TEMPLATE_WALL0005,
	TEMPLATE_WALL0006,
	TEMPLATE_WALL0007,
	TEMPLATE_WALL0008,
	TEMPLATE_WALL0009,
	TEMPLATE_WALL0010,
	TEMPLATE_WALL0011,
	TEMPLATE_WALL0012,
	TEMPLATE_WALL0013,
	TEMPLATE_WALL0014,
	TEMPLATE_WALL0015,
	TEMPLATE_WALL0016,
	TEMPLATE_WALL0017,
	TEMPLATE_WALL0018,
	TEMPLATE_WALL0019,
	TEMPLATE_WALL0020,
	TEMPLATE_WALL0021,
	TEMPLATE_WALL0022,
	TEMPLATE_WALL0023,
	TEMPLATE_WALL0024,
	TEMPLATE_WALL0025,
	TEMPLATE_WALL0026,
	TEMPLATE_WALL0027,
	TEMPLATE_WALL0028,
	TEMPLATE_WALL0029,
	TEMPLATE_WALL0030,
	TEMPLATE_WALL0031,
	TEMPLATE_WALL0032,
	TEMPLATE_WALL0033,
	TEMPLATE_WALL0034,
	TEMPLATE_WALL0035,
	TEMPLATE_WALL0036,
	TEMPLATE_WALL0037,
	TEMPLATE_WALL0038,
	TEMPLATE_WALL0039,
	TEMPLATE_WALL0040,
	TEMPLATE_WALL0041,
	TEMPLATE_WALL0042,
	TEMPLATE_WALL0043,
	TEMPLATE_WALL0044,
	TEMPLATE_WALL0045,
	TEMPLATE_WALL0046,
	TEMPLATE_WALL0047,
	TEMPLATE_WALL0048,
	TEMPLATE_WALL0049,
	TEMPLATE_BRIDGE1H,
	TEMPLATE_BRIDGE2H,
	TEMPLATE_BRIDGE_1AX,
	TEMPLATE_BRIDGE_2AX,
	TEMPLATE_BRIDGE1X,
	TEMPLATE_BRIDGE2X,

	TEMPLATE_XTRA0001,
	TEMPLATE_XTRA0002,
	TEMPLATE_XTRA0003,
	TEMPLATE_XTRA0004,
	TEMPLATE_XTRA0005,
	TEMPLATE_XTRA0006,
	TEMPLATE_XTRA0007,
	TEMPLATE_XTRA0008,
	TEMPLATE_XTRA0009,
	TEMPLATE_XTRA0010,
	TEMPLATE_XTRA0011,
	TEMPLATE_XTRA0012,
	TEMPLATE_XTRA0013,
	TEMPLATE_XTRA0014,
	TEMPLATE_XTRA0015,
	TEMPLATE_XTRA0016,

#ifdef FIXIT_ANTS
	TEMPLATE_HILL01,
#endif


	TEMPLATE_COUNT,
	TEMPLATE_NONE=65535,
	TEMPLATE_FIRST=0
} TemplateType;

//PG inline TemplateType operator++(TemplateType &, int);
inline TemplateType operator++(TemplateType &n) { n = (TemplateType)(((int)n) + 1); return n; }

/**********************************************************************
**	The three dimensional terrain objects are enumerated here. These
**	objects function similar to buildings in that they can be driven
**	behind and can take damage on an individual basis.
*/
typedef enum TerrainType : char {
	TERRAIN_NONE=-1,
	TERRAIN_TREE1,
	TERRAIN_TREE2,
	TERRAIN_TREE3,
	TERRAIN_TREE5,
	TERRAIN_TREE6,
	TERRAIN_TREE7,
	TERRAIN_TREE8,
	TERRAIN_TREE10,
	TERRAIN_TREE11,
	TERRAIN_TREE12,
	TERRAIN_TREE13,
	TERRAIN_TREE14,
	TERRAIN_TREE15,
	TERRAIN_TREE16,
	TERRAIN_TREE17,
	TERRAIN_CLUMP1,
	TERRAIN_CLUMP2,
	TERRAIN_CLUMP3,
	TERRAIN_CLUMP4,
	TERRAIN_CLUMP5,

	TERRAIN_ICE01,
	TERRAIN_ICE02,
	TERRAIN_ICE03,
	TERRAIN_ICE04,
	TERRAIN_ICE05,

	TERRAIN_BOXES01,
	TERRAIN_BOXES02,
	TERRAIN_BOXES03,
	TERRAIN_BOXES04,
	TERRAIN_BOXES05,
	TERRAIN_BOXES06,
	TERRAIN_BOXES07,
	TERRAIN_BOXES08,
	TERRAIN_BOXES09,

	TERRAIN_MINE,

	TERRAIN_COUNT,
	TERRAIN_FIRST=0
} TerrainType;

//PG inline TerrainType operator++(TerrainType &, int);


/**********************************************************************
**	Smudges are enumerated here. Smudges are transparent icons that are
**	drawn over the underlying terrain in order to give the effect of
**	alterations to the terrain. Craters are a good example of this.
*/
typedef enum SmudgeType : char {
	SMUDGE_NONE=-1,
	SMUDGE_CRATER1,
	SMUDGE_CRATER2,
	SMUDGE_CRATER3,
	SMUDGE_CRATER4,
	SMUDGE_CRATER5,
	SMUDGE_CRATER6,
	SMUDGE_SCORCH1,
	SMUDGE_SCORCH2,
	SMUDGE_SCORCH3,
	SMUDGE_SCORCH4,
	SMUDGE_SCORCH5,
	SMUDGE_SCORCH6,
	SMUDGE_BIB1,
	SMUDGE_BIB2,
	SMUDGE_BIB3,

	SMUDGE_COUNT,
	SMUDGE_FIRST=0
} SmudgeType;

//PG inline SmudgeType operator++(SmudgeType &, int);


/**********************************************************************
**	Animations are enumerated here. Animations are the high speed and
**	short lived effects that occur with explosions and fire.
*/
typedef enum AnimType : char {
	ANIM_NONE=-1,
	ANIM_FBALL1,					// Large fireball explosion (bulges rightward).
	ANIM_FBALL_FADE,				// Fading fireball puff.
	ANIM_FRAG1,						// Medium fragment throwing explosion -- short decay.
	ANIM_VEH_HIT1,					//	Small fireball explosion (bulges rightward).
	ANIM_VEH_HIT2,					//	Small fragment throwing explosion -- pop & sparkles.
	ANIM_VEH_HIT3,					// Small fragment throwing explosion -- burn/exp mix.
	ANIM_ART_EXP1,					// Large fragment throwing explosion -- many sparkles.
	ANIM_NAPALM1,					// Small napalm burn.
	ANIM_NAPALM2,					// Medium napalm burn.
	ANIM_NAPALM3,					// Large napalm burn.
	ANIM_SMOKE_PUFF,				// Small rocket smoke trail puff.
	ANIM_PIFF,						// Machine gun impact piffs.
	ANIM_PIFFPIFF,					// Chaingun impact piffs.
	ANIM_FIRE_SMALL,				// Small flame animation.
	ANIM_FIRE_MED,					// Medium flame animation.
	ANIM_FIRE_MED2,				// Medium flame animation (oranger).
	ANIM_FIRE_TINY,				// Very tiny flames.
	ANIM_MUZZLE_FLASH,			// Big cannon flash (with translucency).
	ANIM_SMOKE_M,					// Smoke rising from ground.
	ANIM_BURN_SMALL,				// Small combustible fire effect (with trail off).
	ANIM_BURN_MED,					// Medium combustible fire effect (with trail off).
	ANIM_BURN_BIG,					// Large combustible fire effect (with trail off).
	ANIM_ON_FIRE_SMALL,			// Burning effect for buildings.
	ANIM_ON_FIRE_MED,				// Burning effect for buildings.
	ANIM_ON_FIRE_BIG,				// Burning effect for buildings.
	ANIM_SAM_N,
	ANIM_SAM_NE,
	ANIM_SAM_E,
	ANIM_SAM_SE,
	ANIM_SAM_S,
	ANIM_SAM_SW,
	ANIM_SAM_W,
	ANIM_SAM_NW,
	ANIM_GUN_N,
	ANIM_GUN_NE,
	ANIM_GUN_E,
	ANIM_GUN_SE,
	ANIM_GUN_S,
	ANIM_GUN_SW,
	ANIM_GUN_W,
	ANIM_GUN_NW,
	ANIM_LZ_SMOKE,
	ANIM_CRATE_DEVIATOR,			// Red finned missile.
	ANIM_CRATE_DOLLAR,			// Dollar sign.
	ANIM_CRATE_EARTH,				// Cracked Earth.
	ANIM_CRATE_EMPULSE,			// Plasma ball.
	ANIM_CRATE_INVUN,				// Orange sphere with green rings.
	ANIM_CRATE_MINE,				// Spiked mine.
	ANIM_CRATE_RAPID,				// Red skull.
	ANIM_CRATE_STEALTH,			// Cloaking sphere.
	ANIM_CRATE_MISSILE,			// Green finned missile.
	ANIM_MOVE_FLASH,
	ANIM_OILFIELD_BURN,
	ANIM_ELECT_DIE,				// Electrocution infantryman death from Tesla coil
	ANIM_PARACHUTE,				// Parachute (designed to be attached to object).
	ANIM_DOG_ELECT_DIE,			// Electrocution dog death from Tesla coil
	ANIM_CORPSE1,
	ANIM_CORPSE2,
	ANIM_CORPSE3,
	ANIM_SPUTDOOR,
	ANIM_ATOM_BLAST,
	ANIM_CHRONO_BOX,
	ANIM_GPS_BOX,
	ANIM_INVUL_BOX,
	ANIM_PARA_BOX,
	ANIM_SONAR_BOX,
	ANIM_TWINKLE1,
	ANIM_TWINKLE2,
	ANIM_TWINKLE3,
	ANIM_FLAK,
	ANIM_WATER_EXP1,
	ANIM_WATER_EXP2,
	ANIM_WATER_EXP3,
	ANIM_CRATE_ARMOR,
	ANIM_CRATE_SPEED,
	ANIM_CRATE_FPOWER,
	ANIM_CRATE_TQUAKE,
	ANIM_PARA_BOMB,
	ANIM_MINE_EXP1,
	ANIM_FLAG,
	ANIM_BEACON,

#ifdef FIXIT_ANTS
	ANIM_ANT1_DEATH,
	ANIM_ANT2_DEATH,
	ANIM_ANT3_DEATH,
#endif

	ANIM_FIRE_SMALL_VIRTUAL,			// Small flame animation.
	ANIM_FIRE_MED_VIRTUAL,				// Medium flame animation.
	ANIM_FIRE_MED2_VIRTUAL,				// Medium flame animation (oranger).
	ANIM_FIRE_TINY_VIRTUAL,				// Very tiny flames.
	ANIM_BEACON_VIRTUAL,		// Beacon (virtual).

	ANIM_COUNT,
	ANIM_FIRST=0
} AnimType;


inline AnimType operator++(AnimType &, int);


/****************************************************************************
**	Infantry can be performing various activities. These can range from simple
**	idle animations to physical hand to hand combat.
*/
typedef enum DoType : char {
	DO_NOTHING=-1,				// Not performing any choreographed sequence.
	DO_STAND_READY=0,
	DO_STAND_GUARD,
	DO_PRONE,
	DO_WALK,
	DO_FIRE_WEAPON,
	DO_LIE_DOWN,
	DO_CRAWL,
	DO_GET_UP,
	DO_FIRE_PRONE,
	DO_IDLE1,
	DO_IDLE2,
	DO_GUN_DEATH,
	DO_EXPLOSION_DEATH,
	DO_EXPLOSION2_DEATH,
	DO_GRENADE_DEATH,
	DO_FIRE_DEATH,
	DO_GESTURE1,
	DO_SALUTE1,
	DO_GESTURE2,
	DO_SALUTE2,
	DO_DOG_MAUL,

	DO_COUNT,
	DO_FIRST=0
} DoType;

inline DoType operator++(DoType &, int);

/*
**	This structure is associated with each maneuver type. It tells whether the
**	maneuver can be interrupted and the frame rate.
*/
typedef struct {
	unsigned Interrupt:1;	// Can it be interrupted?
	unsigned IsMobile:1;		// Can it move while doing this?
	unsigned RandomStart:1;	// Should animation be "randomized"?
	unsigned char Rate;		// Frame rate.
} DoStruct;

typedef struct {
	int				Frame;	// Starting frame of the animation.
	unsigned char	Count;	// Number of frames of animation.
	unsigned char	Jump;		// Frames to jump between facings.
} DoInfoStruct;


/****************************************************************************
**	These are the various radio message that can be transmitted between
**	units and buildings. Some of these require a response from the receiver
**	and some don't.
*/
typedef enum RadioMessageType : unsigned char {
	RADIO_STATIC,				// "hisssss" -- non-message
	RADIO_ROGER,				// "Roger."
	RADIO_HELLO,				// "Come in. I wish to talk."
	RADIO_OVER_OUT,			// "Something came up, bye."
	RADIO_PICK_UP,				// "Please pick me up."
	RADIO_ATTACH,				// "Attach to transport."
	RADIO_DELIVERY,			// "I've got a delivery for you."
	RADIO_HOLD_STILL,			// "I'm performing load/unload maneuver. Be careful."
	RADIO_UNLOADED,			// "I'm clear."
	RADIO_UNLOAD,				// "You are clear to unload. Please start driving off now."
	RADIO_NEGATIVE,			// "Am unable to comply."
	RADIO_BUILDING,			// "I'm starting construction now... act busy."
	RADIO_COMPLETE,			// "I've finished construction. You are free."
	RADIO_REDRAW,				// "Oops, sorry. I might have bumped you a little."
	RADIO_DOCKING,				// "I'm trying to load up now."
	RADIO_CAN_LOAD,			// "May I become a passenger?"
	RADIO_ARE_REFINERY,		// "Are you a refinery ready to take shipment?"
	RADIO_TRYING_TO_LOAD,	// "Are you trying to become a passenger?"
	RADIO_MOVE_HERE,			// "Move to location X."
	RADIO_NEED_TO_MOVE,		// "Do you need to move somewhere?"
	RADIO_YEA_NOW_WHAT,		// "All right already. Now what?"
	RADIO_IM_IN,				// "I'm a passenger now."
	RADIO_BACKUP_NOW,			// "Begin backup into refinery now."
	RADIO_RUN_AWAY,			// "Run away! Run away!"
	RADIO_TETHER,				// "Establish tether contact."
	RADIO_UNTETHER,			// "Break tether contact."
	RADIO_REPAIR,				// "Repair one step."
	RADIO_PREPARED,			// "Are you prepared to fight?"
	RADIO_ATTACK_THIS,		// "Attack this target please."
	RADIO_RELOAD,				// "Reload one step please."
	RADIO_CANT,					// "Circumstances prevent success."
	RADIO_ALL_DONE,			// "I have completed the task."
	RADIO_NEED_REPAIR,		// "Are you in need of service depot work?"
	RADIO_ON_DEPOT,			// "Are you sitting on a service depot?"

	RADIO_COUNT
} RadioMessageType;


/****************************************************************************
**	Various trigger events and actions require additional data. This enumeration is
**	used to indicate what kind of additional data is required. This is also used
**	for team mission types that might need additional data.
*/
typedef enum NeedType : unsigned char {
	NEED_NONE,					// No additional data is required.
	NEED_THEME,					// Need a musical theme.
	NEED_MOVIE,					// Need a movie to play.
	NEED_SOUND,					// Sound effect.
	NEED_SPEECH,				// Speech from EVA.
	NEED_INFANTRY,				// Infantry type class.
	NEED_UNIT,					// Unit type class.
	NEED_AIRCRAFT,				// Aircraft type class.
	NEED_STRUCTURE,			// Structure type class.
	NEED_WAYPOINT,				// Waypoint letter.
	NEED_NUMBER,				// General number.
	NEED_TRIGGER,				//	Trigger object reference.
	NEED_TEAM,					// Team type class.
	NEED_HOUSE,					// House type number.
	NEED_TIME,					// Time delay value required.
	NEED_QUARRY,				// Quarry type is needed.
	NEED_FORMATION,			// A formation type is needed.
	NEED_BOOL,					// Boolean value is needed.
	NEED_SPECIAL,				// Special weapon ability.
	NEED_MISSION,				// General unit mission type.
	NEED_HEX_NUMBER			// General number.
} NeedType;


/****************************************************************************
**	There are various target types that teams and special weapons can be
**	assigned to attack. These are general target categories since the actual
**	disposition of potential targets cannot be precisely predicted -- thus these
**	serve as guidelines for the computer AI.
*/
typedef enum QuarryType : unsigned char {
	QUARRY_NONE,

	QUARRY_ANYTHING,					// Attack any enemy (same as "hunt").
	QUARRY_BUILDINGS,					// Attack buildings (in general).
	QUARRY_HARVESTERS,				// Attack harvesters or refineries.
	QUARRY_INFANTRY,					// Attack infantry.
	QUARRY_VEHICLES,					// Attack combat vehicles.
	QUARRY_VESSELS,					// Attach ships.
	QUARRY_FACTORIES,					// Attack factories (all types).
	QUARRY_DEFENSE,					// Attack base defense buildings.
	QUARRY_THREAT,						// Attack enemies near friendly base.
	QUARRY_POWER,						// Attack power facilities.
	QUARRY_FAKES,						// Prefer to attack fake buildings.

	QUARRY_COUNT,
	QUARRY_FIRST=0
} QuarryType;


/****************************************************************************
**	Teams can be assigned formations. This specifies the various formations that
**	a team can be composed into.
*/
typedef enum FormationType : unsigned char {
	FORMATION_NONE,

	FORMATION_TIGHT,				// Tight grouping (vulnerable units in center).
	FORMATION_LOOSE,				// Loose grouping (one cell separation between units).
	FORMATION_WEDGE_N,			// Wedge shape.
	FORMATION_WEDGE_E,			// Wedge shape.
	FORMATION_WEDGE_S,			// Wedge shape.
	FORMATION_WEDGE_W,			// Wedge shape.
	FORMATION_LINE_NS,			// Column formation.
	FORMATION_LINE_EW,			// Line formation.

	FORMATION_COUNT,
	FORMATION_FIRST=0
} FormationType;


/****************************************************************************
**	Selected units have a special selected unit box around them. These are the
**	defines for the two types of selected unit boxes. One is for infantry and
**	the other is for regular units.
*/
typedef enum SelectEnum : char {
	SELECT_NONE=-1,
	SELECT_INFANTRY,					// Small infantry selection box.
	SELECT_UNIT,						// Big unit selection box.
	SELECT_BUILDING=SELECT_UNIT,	// Custom box for buildings.
	SELECT_TERRAIN=SELECT_UNIT,	// Custom box for terrain objects.
	SELECT_WRENCH,						// A building is repairing overlay graphic.

	SELECT_COUNT
} SelectEnum;


/****************************************************************************
**	The pip shapes and text shapes are enumerated according to the following
**	type. These special shapes are drawn over special objects or in other places
**	where shape technology is needed.
*/
typedef enum PipEnum : unsigned char 
{
	PIP_EMPTY,			// Empty pip spot.
	PIP_FULL,			// Full pip spot.
	PIP_PRIMARY,		// "Primary" building marker.
	PIP_READY,			// "Ready" construction information tag.
	PIP_HOLDING,		// "Hold"ing construction information tag.
	PIP_ENGINEER,		// Full pip with engineer coloring.
	PIP_CIVILIAN,		// Full pip with civilian coloring.
	PIP_COMMANDO,		// Full pip with commando coloring.
	PIP_NUMBERS,		// digit 0
	PIP_NUMBER1,		// digit 1
	PIP_NUMBER2,		// digit 2
	PIP_NUMBER3,		// digit 3
	PIP_NUMBER4,		// digit 4
	PIP_NUMBER5,		// digit 5
	PIP_NUMBER6,		// digit 6
	PIP_NUMBER7,		// digit 7
	PIP_NUMBER8,		// digit 8
	PIP_NUMBER9,		// digit 9
	PIP_DECOY,			// word "Decoy" for fake buildings
	PIP_LETTERF,		// letter 'F' for signifying in-formation
	PIP_MEDIC,			// Little medic red cross.
	PIP_PRI				// Abbreviated "Primary" for kennel
} PipEnum;


/****************************************************************************
**	The radar map can be in one of several states depending on the presense of
**	certain structures and power levels.
*/
typedef enum RadarEnum : unsigned char
{
	RADAR_NONE,	// Radar map doesn't exist at all
	RADAR_OFF,	// Radar map is present, but displayed as off and non-interactive
	RADAR_ON	// Radar map is present, visible, and fully interactive
} RadarEnum;


/****************************************************************************
**	The mouse cursor can be in different states. These states are listed
**	below. Some of these represent animating mouse cursors. The mouse
**	is controlled by passing one of these values to the appropriate
**	MouseClass member function.
*/
typedef enum MouseType : unsigned char
{
	MOUSE_NORMAL,
	MOUSE_N,
	MOUSE_NE,
	MOUSE_E,
	MOUSE_SE,
	MOUSE_S,
	MOUSE_SW,
	MOUSE_W,
	MOUSE_NW,
	MOUSE_NO_N,
	MOUSE_NO_NE,
	MOUSE_NO_E,
	MOUSE_NO_SE,
	MOUSE_NO_S,
	MOUSE_NO_SW,
	MOUSE_NO_W,
	MOUSE_NO_NW,
	MOUSE_NO_MOVE,
	MOUSE_CAN_MOVE,
	MOUSE_ENTER,
	MOUSE_DEPLOY,
	MOUSE_CAN_SELECT,
	MOUSE_CAN_ATTACK,
	MOUSE_SELL_BACK,
	MOUSE_SELL_UNIT,
	MOUSE_REPAIR,
	MOUSE_NO_REPAIR,
	MOUSE_NO_SELL_BACK,
	MOUSE_RADAR_CURSOR,
	MOUSE_NUCLEAR_BOMB,
	MOUSE_AIR_STRIKE,
	MOUSE_DEMOLITIONS,
	MOUSE_AREA_GUARD,
	MOUSE_HEAL,
	MOUSE_DAMAGE,					// Engineer entering building to damage it.
	MOUSE_GREPAIR,					// Engineer entering friendly building to heal it.
	MOUSE_STAY_ATTACK,
	MOUSE_NO_DEPLOY,
	MOUSE_NO_ENTER,
	MOUSE_NO_GREPAIR,
	MOUSE_CHRONO_SELECT,
	MOUSE_CHRONO_DEST,

	MOUSE_COUNT
} MouseType;


/**********************************************************************
**	This structure is used to control the box relief style drawn by
**	the Draw_Box() function.
*/
typedef struct {
	int	Filler;		// Center box fill color.
	int	Shadow;		// Shadow color (darker).
	int	Highlight;	// Highlight color (lighter).
	int	Corner;		// Corner color (transition).
} BoxStyleType;

typedef enum BoxStyleEnum : unsigned char {
	BOXSTYLE_DOWN,					// Typical depressed edge border.
	BOXSTYLE_RAISED,				// Typical raised edge border.
	BOXSTYLE_DIS_DOWN,			// Disabled but depressed.
	BOXSTYLE_DIS_RAISED,			// Disabled but raised.
	BOXSTYLE_BOX,					// list box.
	BOXSTYLE_BORDER,				// main dialog box.

	BOXSTYLE_COUNT
} BoxStyleEnum;


/**********************************************************************
**	Damage, as inflicted by projectiles, has different characteristics.
**	These are the different "warhead" types that can be assigned to the
**	various projectiles in the game.
*/
typedef enum WarheadType : char {
	WARHEAD_NONE=-1,

	WARHEAD_SA,					// Small arms -- good against infantry.
	WARHEAD_HE,					//	High explosive -- good against buildings & infantry.
	WARHEAD_AP,					// Armor piercing -- good against armor.
	WARHEAD_FIRE,				// Incendiary -- Good against flammables.
	WARHEAD_HOLLOW_POINT,	// Sniper bullet type.
	WARHEAD_TESLA,				// Electrocution warhead for infantrymen
	WARHEAD_DOG,				// Slavering attack beast mauling infantryman
	WARHEAD_NUKE,				// Nuclear missile
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
	WARHEAD_MECHANICAL,		// repair weapon for vehicles
#endif
	WARHEAD_COUNT,
	WARHEAD_FIRST=0
} WarheadType;


/**********************************************************************
**	This enumerates the various weapon types. The weapon is characterized
**	by the projectile it launches, the damage it does, and the rate of
**	fire.
*/
typedef enum WeaponType : char {
	WEAPON_NONE=-1,

	WEAPON_COLT45,
	WEAPON_ACK_ACK,
	WEAPON_VULCAN,
	WEAPON_MAVERICK,
	WEAPON_CAMERA,
	WEAPON_FIREBALL,
	WEAPON_RIFLE,
	WEAPON_CHAIN_GUN,
	WEAPON_PISTOL,
	WEAPON_M16,
	WEAPON_DRAGON,
	WEAPON_HELLFIRE,
	WEAPON_GRENADE,
	WEAPON_75MM,
	WEAPON_90MM,
	WEAPON_105MM,
	WEAPON_120MM,
	WEAPON_TURRET_GUN,
	WEAPON_MAMMOTH_TUSK,
	WEAPON_155MM,
	WEAPON_M60MG,
	WEAPON_NAPALM,
	WEAPON_TESLA_ZAP,
	WEAPON_NIKE,
	WEAPON_8INCH,
	WEAPON_STINGER,
	WEAPON_TORPEDO,
	WEAPON_2INCH,
	WEAPON_DEPTH_CHARGE,
	WEAPON_PARA_BOMB,
	WEAPON_DOGJAW,
	WEAPON_HEAL,
	WEAPON_SCUD,
	WEAPON_FLAMER,
	WEAPON_REDEYE,

#ifdef FIXIT_ANTS
	WEAPON_MANDIBLE,
#endif

#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
	WEAPON_PORTATESLA,
	WEAPON_GOODWRENCH,
	WEAPON_SUBSCUD,
	WEAPON_TTANKZAP,
	WEAPON_APTUSK,
	WEAPON_DEMOCHARGE,
#endif
#ifdef FIXIT_CARRIER	//	checked - ajw 9/28/98
	WEAPON_CARRIER,
#endif


	WEAPON_COUNT,
	WEAPON_FIRST=0
} WeaponType;


/**********************************************************************
**	The various armor types are best suited to defend against a limited
**	kind of warheads. The game strategy revolves around proper
**	combination of armor and weaponry. Each vehicle or building has armor
**	rated according to one of the following types.
*/
typedef enum ArmorType : unsigned char {
	ARMOR_NONE,			// Vulnerable to SA and HE.
	ARMOR_WOOD,			// Vulnerable to HE and Fire.
	ARMOR_ALUMINUM,	// Vulnerable to AP and SA.
	ARMOR_STEEL,		// Vulnerable to AP.
	ARMOR_CONCRETE,	// Vulnerable to HE and AP.

	ARMOR_COUNT,
	ARMOR_FIRST=0
} ArmorType;


/**********************************************************************
**	These are the identifiers for the various monochrome debug screens.
*/
typedef enum DMonoType : unsigned char {
	DMONO_OBJECT,
	DMONO_HOUSE,
	DMONO_STRESS,
	DMONO_EVENTS,

	DMONO_COUNT,
	DMONO_FIRST=0
} DMonoType;

/*
**	Performance benchmark tracking identifiers.
*/
typedef enum BenchType : unsigned char {
	BENCH_GAME_FRAME,			// Whole game frame (used for normalizing).
	BENCH_FINDPATH,			// Find path calls.
	BENCH_GREATEST_THREAT,	// Greatest threat calculation.
	BENCH_AI,					// Object AI calls.
	BENCH_CELL,					// Cell draw it function.
	BENCH_SIDEBAR,				// Sidebar (just cameo section) drawing.
	BENCH_RADAR,				// Radar map drawing.
	BENCH_TACTICAL,			// Whole tactical map.
	BENCH_PCP,					// Per cell process.
	BENCH_EVAL_OBJECT,		// Evaluate object as potential target.
	BENCH_EVAL_CELL,			// Evaluate entire cell for potential targets.
	BENCH_EVAL_WALL,			// Evaluate wall in cell as potential target.

	BENCH_POWER,				// Power bar drawing.
	BENCH_TABS,					// Tab section (top) drawing.
	BENCH_SHROUD,				// Shroud layer drawing.
	BENCH_ANIMS,				// Animations drawing.
	BENCH_OBJECTS,				// All game object drawing.
	BENCH_PALETTE,				// Color cycling palette adjustments.
	BENCH_GSCREEN_RENDER,	// Rendering of the whole map layered system (with blits).
	BENCH_BLIT_DISPLAY,		// DirectX or shadow blit of hidpage to seenpage.
	BENCH_MISSION,				// Mission list processing.

	BENCH_RULES,				// Processing of the rules.ini file.
	BENCH_SCENARIO,			// Processing of the scenario.ini file.

	BENCH_COUNT,
	BENCH_FIRST=0
} BenchType;


#ifdef CHEAT_KEYS
#define	BStart(a)	if (Benches != NULL) Benches[a].Begin()
#define	BEnd(a)		if (Benches != NULL) Benches[a].End()
#else
#define	BStart(a)
#define	BEnd(a)
#endif


/**********************************************************************
**	Working MCGA colors that give a pleasing effect for beveled edges and
**	other purposes.
*/
#define	MAGIC_COL_COUNT	13		// Translucent color count.
#define	SHADOW_COL_COUNT	4		// Terrain shroud translucent color count.
#define	USHADOW_COL_COUNT	1		// Unit shadow special ghost colors.


/**********************************************************************
**	Color cycling range that is used for water effects.
*/
#define	CYCLE_COLOR_START		(6*16)
#define	CYCLE_COLOR_COUNT		7


/**********************************************************************
**	Magic color fading pulsing effect limits -- color gun value.
*/
#define	CC_PULSE_COLOR			255
#define	CC_EMBER_COLOR			(CYCLE_COLOR_START+CYCLE_COLOR_COUNT)


/**********************************************************************
**	These are the control flags for Fancy_Text_Print function.
*/
typedef enum TextPrintType : unsigned short {
	TPF_LASTPOINT		=0x0000,		// Use previous font point value.
	TPF_6POINT			=0x0001,		// Use 6 point font.
	TPF_8POINT			=0x0002,		// Use 8 point font.
	TPF_3POINT			=0x0003,		// Use 3 point font.
	TPF_LED				=0x0004,		// Use LED font.
	TPF_VCR				=0x0005,		// Use VCR font.
	TPF_6PT_GRAD		=0x0006,		// Use 6 point gradient font.
	TPF_MAP				=0x0007,		// Font used for popup help text.
	TPF_METAL12			=0x0008,    // Use 12 point tab font
	TPF_EFNT				=0x0009,		// Use scenario editor font.
	TPF_TYPE				=0x000A,		// Use teletype font
	TPF_SCORE			=0x000B,		// Use score screen font.
	TPF_LASTSHADOW		=0x0000,		// Use previous font palette.
	TPF_NOSHADOW		=0x0010,		// Don't have any shadow.
	TPF_DROPSHADOW		=0x0020,		//	Use a simple drop shadow.
	TPF_FULLSHADOW		=0x0040,		// Use a full outline shadow.
	TPF_LIGHTSHADOW	=0x0080,		// Use engraved drop 'shadow' color.
	TPF_CENTER			=0x0100,		// Center about the X axis.
	TPF_RIGHT			=0x0200,		// Right justify text.
	TPF_MEDIUM_COLOR	=0x1000,		// Use medium color for all text gradient
	TPF_BRIGHT_COLOR	=0x2000,		// Use bright color for all text gradient
	TPF_USE_GRAD_PAL	=0x4000		// Use a gradient palette based on fore color
} TextPrintType;

//PG
//inline TextPrintType operator |(TextPrintType, TextPrintType);
//inline TextPrintType operator &(TextPrintType, TextPrintType);
//inline TextPrintType operator ~(TextPrintType);

inline TextPrintType operator|(TextPrintType a, TextPrintType b)
{return static_cast<TextPrintType>(static_cast<int>(a) | static_cast<int>(b));}

inline TextPrintType operator&(TextPrintType a, TextPrintType b)
{return static_cast<TextPrintType>(static_cast<int>(a) & static_cast<int>(b));}

inline TextPrintType operator~(TextPrintType a)
{return static_cast<TextPrintType>(~static_cast<int>(a));}

// Standard button text print flags.
#define TPF_BUTTON	(TPF_CENTER|TPF_6PT_GRAD|TPF_NOSHADOW)
#define TPF_EBUTTON	(TPF_CENTER|TPF_EFNT|TPF_NOSHADOW)
#define TPF_TEXT		(TPF_6PT_GRAD|TPF_NOSHADOW)


/**********************************************************************
**	These control the maximum number of objects in the game. Make sure that these
**	maximums never exceed the maximum value for the "ID" element in the
**	object class.
*/
#define	BUILDING_MAX			500		// Lasts for hours.
#define	HOUSE_MAX				(HOUSE_COUNT+1)	// Lasts entire scenario.
#define	INFANTRY_MAX			500		// Lasts for minutes.
#define	UNIT_MAX					500		// Lasts for minutes.
#define	VESSEL_MAX				100		// Lasts for minutes.
#define	TEAMTYPE_MAX			60			// Lasts forever.

// Save filename description.
#define	DESCRIP_MAX				44			// 40 chars + CR + LF + CTRL-Z + NULL

#define	CONQUER_PATH_MAX		12			// Number of cells to look ahead for movement.

#define	EACH_INFANTRY_MAX		(INFANTRY_MAX/5)		// Default maximum any one player can have.
#define	EACH_UNIT_MAX			(UNIT_MAX/5)			// Default maximum any one player can have.
#define	EACH_BUILDING_MAX		(BUILDING_MAX/5)		// Default maximum any one player can build.
#define	EACH_VESSEL_MAX		(VESSEL_MAX/5)			// Default maximum any one player can build.


/**********************************************************************
**	Terrain can be of these different classes. At any point in the game
**	a particular piece of ground must fall under one of these classifications.
**	This is true, even if it is undergoing a temporary transition.
*/
typedef enum LandType : char {
	LAND_CLEAR,		// "Clear" terrain.
	LAND_ROAD,		// Road terrain.
	LAND_WATER,		// Water.
	LAND_ROCK,		// Impassable rock.
	LAND_WALL,		// Wall (blocks movement).
	LAND_TIBERIUM,	// Tiberium field.
	LAND_BEACH,		//	Beach terrain.
	LAND_ROUGH,		// Rocky terrain.
	LAND_RIVER,		// Rocky riverbed.

	LAND_COUNT,
	LAND_NONE=-1,
	LAND_FIRST=0
} LandType;


/**********************************************************************
**	The theaters of operation are as follows.
*/
typedef enum TheaterType : char {
	THEATER_NONE=-1,
	THEATER_TEMPERATE,
	THEATER_SNOW,
	THEATER_INTERIOR,

	THEATER_COUNT,
	THEATER_FIRST=0
} TheaterType;

//inline TheaterType operator++(TheaterType &, int);
inline TheaterType operator++(TheaterType &n) { n = (TheaterType)(((int)n)+1); return n; }


#define	THEATERF_TEMPERATE		(1<<THEATER_TEMPERATE)
#define	THEATERF_SNOW				(1<<THEATER_SNOW)
#define	THEATERF_INTERIOR			(1<<THEATER_INTERIOR)

typedef struct {
	char		Name[16];
	char		Root[10];
	char		Suffix[4];
} TheaterDataType;


/**********************************************************************
**	Each building has a predetermined size. These are the size numbers.
**	The trailing number is this define is the width and height (respectively)
**	of the building in cells.
*/
typedef enum BSizeType : char {
	BSIZE_NONE=-1,
	BSIZE_11=0,
	BSIZE_21,
	BSIZE_12,
	BSIZE_22,
	BSIZE_23,
	BSIZE_32,
	BSIZE_33,
	BSIZE_42,
	BSIZE_55,

	BSIZE_COUNT
} BSizeType;

inline BSizeType operator++(BSizeType &, int);


/**********************************************************************
** When objects are manipulated on the map that are marked as being
**	removed (up), placed down (down), or just to be redrawn (change);
** or when an object's rendering (not logical) size changes, due to
** its being selected or having an animation attached (overlap up/down).
*/
typedef enum MarkType : unsigned char {
	MARK_UP,					//	Removed from the map.
	MARK_DOWN,				//	Placed on the map.
	MARK_CHANGE,			//	Altered in place on the map.
	MARK_CHANGE_REDRAW,	//	Redraw because of animation change.
	MARK_OVERLAP_DOWN,	// Mark overlap cells on the map
	MARK_OVERLAP_UP		// Clear overlap cells on the map
} MarkType;


/****************************************************************************
**	Window number definition list. Each window should be referred to by
**	the value given in this list.
*/
// Allow window number enums to be passed to library functions.
typedef enum WindowNumberType : unsigned char {
	WINDOW_MAIN,				// Full screen window.
	WINDOW_ERROR,				// Library error window.
	WINDOW_TACTICAL,			// Tactical map window.
	WINDOW_MENU,				// Main selection menu.
	WINDOW_SIDEBAR,			// Sidebar (buildable list) window.
	WINDOW_EDITOR,				// Scenario editor window.
	WINDOW_PARTIAL,			// Partial object draw sub-window.
	WINDOW_CUSTOM,				// Window that can be altered depending on circumstances
	WINDOW_VIRTUAL				// Window that is used when we want to capture rendering information without actually rendering. ST - 1/15/2019 3:03PM
} WindowNumberType;


/****************************************************************************
**	For every cell there are 8 adjacent cells. Use these direction numbers
**	when referring to adjacent cells. This comes into play when moving
**	between cells and in the Desired_Facing() algorithm.
*/
typedef enum FacingType : char {
	FACING_NONE=-1,
	FACING_N,			// North
	FACING_NE,			// North-East
	FACING_E,			// East
	FACING_SE,			// South-East
	FACING_S,			// South
	FACING_SW,			// South-West
	FACING_W,			// West
	FACING_NW,			// North-West

	FACING_COUNT,			// Total of 8 directions (0..7).
	FACING_FIRST=0
} FacingType;

//inline FacingType operator++(FacingType &, int);
inline FacingType operator + (FacingType f1, FacingType f2)
{
	return (FacingType)(((int)f1 + (int)f2) & 0x07);
}
inline FacingType operator + (FacingType f1, int f2)
{
	return (FacingType)(((int)f1 + (int)f2) & 0x07);
}

inline FacingType operator - (FacingType f1, FacingType f2)
{
	return (FacingType)(((int)f1 - (int)f2) & 0x07);
}
inline FacingType operator - (FacingType f1, int f2)
{
	return (FacingType)(((int)f1 - (int)f2) & 0x07);
}

inline FacingType operator += (FacingType & f1, FacingType f2)
{
	f1 = (FacingType)(((int)f1 + (int)f2) & 0x07);
	return(f1);
}
inline FacingType operator += (FacingType & f1, int f2)
{
	f1 = (FacingType)(((int)f1 + (int)f2) & 0x07);
	return(f1);
}

inline int operator * (FacingType f1, FacingType f2)
{
	return((int)f1 * (int)f2);
}


#ifdef NEVER
typedef enum DirType {
	DIR_MIN=0,
	DIR_N=0,
	DIR_NE=1<<5,
	DIR_E=2<<5,
	DIR_SE=3<<5,
	DIR_S=4<<5,
	DIR_SW=5<<5,
	DIR_SW_X1=(5<<5)-8,		// Direction of harvester while unloading.
	DIR_SW_X2=(5<<5)-16,		// Direction of harvester while unloading.
	DIR_W=6<<5,
	DIR_NW=7<<5,
	DIR_MAX=255
} DirType;
inline DirType operator + (DirType f1, DirType f2)
{
	return (DirType)(((int)f1 + (int)f2) & 0x00FF);
}
inline DirType operator + (DirType f1, int f2)
{
	return (DirType)(((int)f1 + (int)f2) & 0x00FF);
}
#endif
#define DIR_SW_X1	DirType((5<<5)-8)
#define DIR_SW_X2	DirType((5<<5)-16)


/****************************************************************************
**	Timer constants. These are used when setting the countdown timer.
**	Note that this is based upon a timer that ticks every 60th of a second.
*/
#define	TIMER_SECOND			60
#define	TIMER_MINUTE			(TIMER_SECOND*60)

#define	FADE_PALETTE_FAST		(TIMER_SECOND/8)
#define	FADE_PALETTE_MEDIUM	(TIMER_SECOND/4)
#define	FADE_PALETTE_SLOW		(TIMER_SECOND/2)

#define	TICKS_PER_SECOND		15
#define	TICKS_PER_MINUTE		(TICKS_PER_SECOND * 60)
#define	TICKS_PER_HOUR			(TICKS_PER_MINUTE * 60)

#define	GRAYFADETIME			(1 * TICKS_PER_SECOND)


/****************************************************************************
** Each vehicle is give a speed rating. This is a combination of not only
**	its physical speed, but the means by which it travels (wheels, tracks,
**	wings, etc). This is used to determine the movement table.
*/
typedef enum SpeedType : char {
	SPEED_NONE=-1,

	SPEED_FOOT,					// Bipedal.
	SPEED_TRACK,				// Tracked locomotion.
	SPEED_WHEEL,				// Balloon tires.
	SPEED_WINGED,				// Lifter's, 'thopters, and rockets.
	SPEED_FLOAT,				// Ships.

	SPEED_COUNT,
	SPEED_FIRST=SPEED_FOOT
} SpeedType;


/**********************************************************************
**	These are the sound effect digitized sample file names.
*/
typedef enum VocType : short {
	VOC_NONE=-1,

	VOC_GIRL_OKAY,			// "okay"
	VOC_GIRL_YEAH,			// "yeah?"
	VOC_GUY_OKAY,			//	"okay"
	VOC_GUY_YEAH,			// "yeah?"

	VOC_MINELAY1,			// mine layer sound
	VOC_ACKNOWL,			//	"acknowledged"
	VOC_AFFIRM,				//	"affirmative"
	VOC_AWAIT,				//	"awaiting orders"
	VOC_ENG_AFFIRM,		// Engineer: "affirmative"
	VOC_ENG_ENG,			// Engineer: "engineering"
	VOC_NO_PROB,			//	"not a problem"
	VOC_READY,				//	"ready and waiting"
	VOC_REPORT,				//	"reporting"
	VOC_RIGHT_AWAY,		//	"right away sir"
	VOC_ROGER,				//	"roger"
	VOC_UGOTIT,				//	"you got it"
	VOC_VEHIC,				//	"vehicle reporting"
	VOC_YESSIR,				//	"yes sir"

	VOC_SCREAM1,			//	short infantry scream
	VOC_SCREAM3,			//	short infantry scream
	VOC_SCREAM4,			//	short infantry scream
	VOC_SCREAM5,			//	short infantry scream
	VOC_SCREAM6,			//	short infantry scream
	VOC_SCREAM7,			//	short infantry scream
	VOC_SCREAM10,			//	short infantry scream
	VOC_SCREAM11,			//	short infantry scream
	VOC_YELL1,				//	long infantry scream

	VOC_CHRONO,				//	Chronosphere sound.
	VOC_CANNON1,			// Cannon sound (medium).
	VOC_CANNON2,			// Cannon sound (short).
	VOC_IRON1,
	VOC_ENG_MOVEOUT,		// Engineer: "movin' out"
	VOC_SONAR,				// sonar pulse
	VOC_SANDBAG,			// sand bag crunch
	VOC_MINEBLOW,
	VOC_CHUTE1,				// wind swoosh sound
	VOC_DOG_BARK,			// dog bark
	VOC_DOG_WHINE,			// dog whine
	VOC_DOG_GROWL2,		// strong dog growl
	VOC_FIRE_LAUNCH,		// fireball launch sound
	VOC_FIRE_EXPLODE,		// fireball explode sound
	VOC_GRENADE_TOSS,		// grenade toss
	VOC_GUN_5,				// 5 round gun burst (slow).
	VOC_GUN_7,				// 7 round gun burst (fast).
	VOC_ENG_YES,			// Engineer: "yes sir"
	VOC_GUN_RIFLE,			// Rifle shot.
	VOC_HEAL,				// Healing effect.
	VOC_DOOR,				// Hyrdrolic door.
	VOC_INVULNERABLE,		// Invulnerability effect.
	VOC_KABOOM1,			// Long explosion (muffled).
	VOC_KABOOM12,			// Very long explosion (muffled).
	VOC_KABOOM15,			// Very long explosion (muffled).
	VOC_SPLASH,				// Water splash
	VOC_KABOOM22,			// Long explosion (sharp).
	VOC_AACANON3,			// AA-Cannon
	VOC_TANYA_DIE,			// Tanya: scream
	VOC_GUN_5F,				// 5 round gun burst (fast).
	VOC_MISSILE_1,			// Missile with high tech effect.
	VOC_MISSILE_2,			// Long missile launch.
	VOC_MISSILE_3,			// Short missile launch.
	VOC_x6,
	VOC_GUN_5R,				// 5 round gun burst (rattles).
	VOC_BEEP,				// Generic beep sound.
	VOC_CLICK,				//	Generic click sound.
	VOC_SILENCER,			// Silencer.
	VOC_CANNON6,			// Long muffled cannon shot.
	VOC_CANNON7,			// Sharp mechanical cannon fire.
	VOC_TORPEDO,			// Torpedo launch.
	VOC_CANNON8,			// Sharp cannon fire.
	VOC_TESLA_POWER_UP,	// Hum charge up.
	VOC_TESLA_ZAP,			// Tesla zap effect.
	VOC_SQUISH,				// Squish effect.
	VOC_SCOLD,				// Scold bleep.
	VOC_RADAR_ON,			// Powering up electronics.
	VOC_RADAR_OFF,			// B movie power down effect.
	VOC_PLACE_BUILDING_DOWN,	// Building slam down sound.
	VOC_KABOOM30,			// Short explosion (HE).
	VOC_KABOOM25,			// Short growling explosion.
	VOC_x7,
	VOC_DOG_HURT,			//	Dog whine.
	VOC_DOG_YES,			// Dog 'yes sir'.
	VOC_CRUMBLE,			// Building crumble.
	VOC_MONEY_UP,			// Rising money tick.
	VOC_MONEY_DOWN,		// Falling money tick.
	VOC_CONSTRUCTION,		// Building construction sound.
	VOC_GAME_CLOSED,		// Long bleep.
	VOC_INCOMING_MESSAGE,	// Soft happy warble.
	VOC_SYS_ERROR,			// Sharp soft warble.
	VOC_OPTIONS_CHANGED,	// Mid range soft warble.
	VOC_GAME_FORMING,		// Long warble.
	VOC_PLAYER_LEFT,		// Chirp sequence.
	VOC_PLAYER_JOINED,	// Reverse chirp sequence.
	VOC_DEPTH_CHARGE,		// Distant explosion sound.
	VOC_CASHTURN,			// Airbrake.

	VOC_TANYA_CHEW,		// Tanya: "Chew on this"
	VOC_TANYA_ROCK,		// Tanya: "Let's rock"
	VOC_TANYA_LAUGH,		// Tanya: "ha ha ha"
	VOC_TANYA_SHAKE,		// Tanya: "Shake it baby"
	VOC_TANYA_CHING,		// Tanya: "Cha Ching"
	VOC_TANYA_GOT,			// Tanya: "That's all you got"
	VOC_TANYA_KISS,		// Tanya: "Kiss it bye bye"
	VOC_TANYA_THERE,		// Tanya: "I'm there"
	VOC_TANYA_GIVE,		// Tanya: "Give it to me"
	VOC_TANYA_YEA,			// Tanya: "Yea?"
	VOC_TANYA_YES,			// Tanya: "Yes sir?"
	VOC_TANYA_WHATS,		// Tanya: "What's up."
	VOC_WALLKILL2,			// Crushing wall sound.
	VOC_x8,
	VOC_TRIPLE_SHOT,		// Three quick shots in succession.
	VOC_SUBSHOW,			// Submarine surfacing.
	VOC_E_AH,				// Einstein "ah"
	VOC_E_OK,				// Einstein "ok"
	VOC_E_YES,				// Einstein "yes"
	VOC_TRIP_MINE,			// mine explosion sound

	VOC_SPY_COMMANDER,	// Spy: "commander?"
	VOC_SPY_YESSIR,		// Spy: "yes sir"
	VOC_SPY_INDEED,		// Spy: "indeed"
	VOC_SPY_ONWAY,			// Spy: "on my way"
	VOC_SPY_KING,			// Spy: "for king and country"
	VOC_MED_REPORTING,	// Medic: "reporting"
	VOC_MED_YESSIR,		// Medic: "yes sir"
	VOC_MED_AFFIRM,		// Medic: "affirmative"
	VOC_MED_MOVEOUT,		// Medic: "movin' out"
	VOC_BEEP_SELECT,		// map selection beep

	VOC_THIEF_YEA,			// Thief: "yea?"

#ifdef FIXIT_ANTS
	VOC_ANTDIE,
	VOC_ANTBITE,
#else
	VOC_x9,
	VOC_x10,
#endif

	VOC_THIEF_MOVEOUT,	// Thief: "movin' out"
	VOC_THIEF_OKAY,		// Thief: "ok"
	VOC_x11,
	VOC_THIEF_WHAT,		// Thief: "what"
	VOC_THIEF_AFFIRM,		// Thief: "affirmative"

	VOC_STAVCMDR,
	VOC_STAVCRSE,
	VOC_STAVYES,
	VOC_STAVMOV,
	VOC_BUZZY1,
	VOC_RAMBO1,
	VOC_RAMBO2,
	VOC_RAMBO3,

#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
	VOC_MECHYES1,
	VOC_MECHHOWDY1,
	VOC_MECHRISE1,
	VOC_MECHHUH1,
	VOC_MECHHEAR1,
	VOC_MECHLAFF1,
	VOC_MECHBOSS1,
	VOC_MECHYEEHAW1,
	VOC_MECHHOTDIG1,
	VOC_MECHWRENCH1,
	VOC_STBURN1,
	VOC_STCHRGE1,
	VOC_STCRISP1,
	VOC_STDANCE1,
	VOC_STJUICE1,
	VOC_STJUMP1,
	VOC_STLIGHT1,
	VOC_STPOWER1,
	VOC_STSHOCK1,
	VOC_STYES1,

	VOC_CHRONOTANK1,
	VOC_MECH_FIXIT1,
	VOC_MAD_CHARGE,
	VOC_MAD_EXPLODE,
	VOC_SHOCK_TROOP1,

	VOC_BEACON,

#endif
	VOC_COUNT,
	VOC_FIRST=0
} VocType;

/*
**	EVA voices are specified by these identifiers.
*/
typedef enum VoxType : char {
	VOX_NONE=-1,
	VOX_ACCOMPLISHED,					//	mission accomplished
	VOX_FAIL,							//	your mission has failed
	VOX_NO_FACTORY,					//	unable to comply, building in progress
	VOX_CONSTRUCTION,					//	construction complete
	VOX_UNIT_READY,					// unit ready
	VOX_NEW_CONSTRUCT,				//	new construction options
	VOX_DEPLOY,							//	cannot deploy here
	VOX_STRUCTURE_DESTROYED,		// structure destroyed
	VOX_INSUFFICIENT_POWER,			// insufficient power
	VOX_NO_CASH,						//	insufficient funds
	VOX_CONTROL_EXIT,					//	battle control terminated
	VOX_REINFORCEMENTS,				//	reinforcements have arrived
	VOX_CANCELED,						//	canceled
	VOX_BUILDING,						//	building
	VOX_LOW_POWER,						//	low power
	VOX_NEED_MO_MONEY,				//	need more funds
	VOX_BASE_UNDER_ATTACK,			//	our base is under attack
	VOX_UNABLE_TO_BUILD,				//	unable to build more
	VOX_PRIMARY_SELECTED,			//	primary building selected
#ifdef ENGLISH
	VOX_MADTANK_DEPLOYED,			// M.A.D. Tank Deployed
#else
	VOX_none3,
#endif
	VOX_none4,
	VOX_UNIT_LOST,						//	unit lost
	VOX_SELECT_TARGET,				// select target
	VOX_PREPARE,						//	enemy approaching
	VOX_NEED_MO_CAPACITY,			//	silos needed
	VOX_SUSPENDED,						//	on hold
	VOX_REPAIRING,						//	repairing
	VOX_none5,
	VOX_none6,
	VOX_AIRCRAFT_LOST,
	VOX_none7,
	VOX_ALLIED_FORCES_APPROACHING,
	VOX_ALLIED_APPROACHING,
	VOX_none8,
	VOX_none9,
	VOX_BUILDING_INFILTRATED,
	VOX_CHRONO_CHARGING,
	VOX_CHRONO_READY,
	VOX_CHRONO_TEST,
	VOX_HQ_UNDER_ATTACK,
	VOX_CENTER_DEACTIVATED,
	VOX_CONVOY_APPROACHING,
	VOX_CONVOY_UNIT_LOST,
	VOX_EXPLOSIVE_PLACED,
	VOX_MONEY_STOLEN,
	VOX_SHIP_LOST,
	VOX_SATALITE_LAUNCHED,
	VOX_SONAR_AVAILABLE,
	VOX_none10,
	VOX_SOVIET_FORCES_APPROACHING,
	VOX_SOVIET_REINFORCEMENTS,
	VOX_TRAINING,
	VOX_ABOMB_READY,
	VOX_ABOMB_LAUNCH,
	VOX_ALLIES_N,
	VOX_ALLIES_S,
	VOX_ALLIES_E,
	VOX_ALLIES_W,
	VOX_OBJECTIVE1,
	VOX_OBJECTIVE2,
	VOX_OBJECTIVE3,
	VOX_IRON_CHARGING,
	VOX_IRON_READY,
	VOX_RESCUED,
	VOX_OBJECTIVE_NOT,
	VOX_SIGNAL_N,
	VOX_SIGNAL_S,
	VOX_SIGNAL_E,
	VOX_SIGNAL_W,
	VOX_SPY_PLANE,
	VOX_FREED,
	VOX_UPGRADE_ARMOR,
	VOX_UPGRADE_FIREPOWER,
	VOX_UPGRADE_SPEED,
	VOX_MISSION_TIMER,
	VOX_UNIT_FULL,
	VOX_UNIT_REPAIRED,
	VOX_TIME_40,
	VOX_TIME_30,
	VOX_TIME_20,
	VOX_TIME_10,
	VOX_TIME_5,
	VOX_TIME_4,
	VOX_TIME_3,
	VOX_TIME_2,
	VOX_TIME_1,
	VOX_TIME_STOP,
	VOX_UNIT_SOLD,
	VOX_TIMER_STARTED,
	VOX_TARGET_RESCUED,
	VOX_TARGET_FREED,
	VOX_TANYA_RESCUED,
	VOX_STRUCTURE_SOLD,
	VOX_SOVIET_FORCES_FALLEN,
	VOX_SOVIET_SELECTED,
	VOX_SOVIET_EMPIRE_FALLEN,
	VOX_OPERATION_TERMINATED,
	VOX_OBJECTIVE_REACHED,
	VOX_OBJECTIVE_NOT_REACHED,
	VOX_OBJECTIVE_MET,
	VOX_MERCENARY_RESCUED,
	VOX_MERCENARY_FREED,
	VOX_KOSOYGEN_FREED,
	VOX_FLARE_DETECTED,
	VOX_COMMANDO_RESCUED,
	VOX_COMMANDO_FREED,
	VOX_BUILDING_IN_PROGRESS,
	VOX_ATOM_PREPPING,
	VOX_ALLIED_SELECTED,
	VOX_ABOMB_PREPPING,
	VOX_ATOM_LAUNCHED,
	VOX_ALLIED_FORCES_FALLEN,
	VOX_ABOMB_AVAILABLE,
	VOX_ALLIED_REINFORCEMENTS,
	VOX_SAVE1,
	VOX_LOAD1,

	VOX_COUNT,
	VOX_FIRST=0
} VoxType;


/****************************************************************************
**	Game reinforcements are each controlled by the following structure. The
**	data originates in the scenario INI file but is then carried throughout
**	any saved games.
*/
typedef enum SourceType : char {
	SOURCE_NONE=-1,				// No defined source (error condition).
	SOURCE_NORTH,					// From north edge.
	SOURCE_EAST,					// From east edge.
	SOURCE_SOUTH,					// From south edge.
	SOURCE_WEST,					// From west edge.
	SOURCE_AIR,						// Dropped by air (someplace).

	SOURCE_COUNT,
	SOURCE_FIRST=0
} SourceType;


/****************************************************************************
**	This entry defines a complete color scheme, with the player's remap table,
** the font remap table, and a color scheme for dialog boxes and buttons.
*/
typedef struct RemapControlType
{
	unsigned char BrightColor;			// Highlight (bright) color index.
	unsigned char Color;					// Normal color index.
	unsigned char RemapTable[256];	// Actual remap table.
	unsigned char FontRemap[16];		// Remap table for gradient font.
	unsigned char Shadow;				// Color of shadowed edge of a raised button.
	unsigned char Background;			// Background fill color for buttons.
	unsigned char Corners;				// Transition color between shadow and highlight.
	unsigned char Highlight;			// Bright edge of raised button.
	unsigned char Box;					// Color for dialog box border.
	unsigned char Bright;				// Color used for highlighted text.
	unsigned char Underline;			// Color for underlining dialog box titles.
	unsigned char Bar;					// Selected entry list box background color.
} RemapControlType;


/****************************************************************************
**	Each type of terrain has certain characteristics. These are indicated
**	by the structure below. For every element of terrain there is a
**	corresponding GroundType structure.
*/
typedef struct {
	fixed	Cost[SPEED_COUNT];	// Terrain effect cost (normal).
	bool				Build;					// Can build on this terrain?
} GroundType;


/**************************************************************************
**	Find_Path returns with a pointer to this structure.
*/
typedef struct {
	CELL				Start;				// Starting cell number.
	int				Cost;					// Accumulated terrain cost.
	int				Length;				// Command string length.
	FacingType		*Command;			// Pointer to command string.
	unsigned long	*Overlap;			// Pointer to overlap list
	CELL				LastOverlap;		// stores position of last overlap
	CELL				LastFixup;			// stores position of last overlap
} PathType;


/**********************************************************************
** These are special indices into the Waypoint array; slots 0-25 are
** reserved for letter-designated Waypoints, the others are special.
*/
typedef enum WaypointEnum : unsigned char 
{
	WAYPT_HOME = 98,				// Home-cell for this scenario
	WAYPT_REINF,					// cell where reinforcements arrive
	WAYPT_SPECIAL,					// Used by special airdrop reinforcements.
	WAYPT_COUNT
} WaypointType;


/****************************************************************************
**	This is the max number of events supported on one frame.
*/
#define	MAX_EVENTS			256

typedef enum : unsigned char {
	KF_NUMBER   = 0x08,
	KF_LCW      = 0x10,
	KF_DELTA    = 0x20,
	KF_KEYDELTA = 0x40,
	KF_KEYFRAME = 0x80,
	KF_MASK     = 0xF0
} KeyFrameType;


/*
** New Config structure for .CFG files
*/
typedef struct {
   unsigned   DigitCard;      	// SoundCardType.
   unsigned   Port;      		 	// SoundCardType.
   unsigned   IRQ;		       	// SoundCardType.
   unsigned   DMA;     		 		// SoundCardType.
   unsigned   BitsPerSample;     // bits per sound sample
   unsigned   Channels;          // stereo/mono sound card
   unsigned   Speed;		         // stereo/mono sound card
	bool       Reverse;				// Reverse left/right speakers
	char       Language[4];
} NewConfigType;


/****************************************************************************
**	These are the types of dialogs that can pop up outside of the main loop,
** an call the game in the background.
*/
typedef enum : unsigned char {
	SDLG_NONE,
	SDLG_OPTIONS,
	SDLG_SURRENDER,
	SDLG_SPECIAL
} SpecialDialogType;

typedef enum : unsigned char {
	CC_MOUSE_COLOR=16
} CCPaletteType;


/****************************************************************************
**	These specify the shape numbers in the OPTIONS.SHP file. These shapes
**	are used to dress up the dialog boxes. Many of these shapes come in pairs.
**	For dialog box shapes, they are left image / right image paired. For buttons,
**	they are up / down paired.
*/
typedef enum OptionControlType : char {
	OPTION_NONE=-1,			// No fancy shmancy shape.
	OPTION_DIALOG=0,			// Small dialog boxes.
	OPTION_CONTROLS=2,		// Large dialog boxes, game controls.
	OPTION_DELETE=4,			// Delete,Load,Save game.
	OPTION_SERIAL=6,			// Serial dialog.
	OPTION_PHONE=8,			// Phone dialog.
	OPTION_VISUAL=10,			// Visual dialog.
	OPTION_NETWORK=12,		// Network dialog.
	OPTION_JOIN_NETWORK=14,	// Join network dialog.
	OPTION_SOUND=16,			// Sound controls.

	OPTION_COUNT
} OptionControlType;


/****************************************************************************
**	Used to store firing data for a unit.
*/
typedef struct {
	COORDINATE Center;
	int Distance;
} FireDataType;


#define size_of(typ,id) sizeof(((typ*)0)->id)


#define MAX_LOG_LEVEL		10

// Maximum number of multi players possible.
#define	MAX_PLAYERS						8		// max # of players we can have

// Maximum number of teams
#define MAX_TEAMS						10

#endif