// // 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.) // #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<(static_cast(a) | static_cast(b));} inline ThreatType operator&(ThreatType a, ThreatType b) {return static_cast(static_cast(a) & static_cast(b));} inline ThreatType operator~(ThreatType a) {return static_cast(~static_cast(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< 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<(static_cast(a) | static_cast(b));} inline TextPrintType operator&(TextPrintType a, TextPrintType b) {return static_cast(static_cast(a) & static_cast(b));} inline TextPrintType operator~(TextPrintType a) {return static_cast(~static_cast(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<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