CodeMirror/CnC_Remastered_Collection
1
0
Fork 0
mirror of https://github.com/electronicarts/CnC_Remastered_Collection synced 2024-04-25 16:02:15 +12:00
Code Issues Releases Wiki Activity
CnC_Remastered_Collection/REDALERT/DEFINES.H
PG-SteveT fd05be35c1 September 16th patch update 
DLL version incremented
Beacon functionality added
Support for loading screen match preview display
Placeholder handling of new key-bindable mod commands
2020-09-16 10:03:04 -07:00

3642 lines
105 KiB
C
Raw Permalink Blame History

//
// 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
Reference in a new issue View git blame Copy permalink