//
// 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: F:\projects\c&c\vcs\code\defines.h_v 2.19 16 Oct 1995 16:44:54 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
//#define PETROGLYPH_EXAMPLE_MOD
/**********************************************************************
** If defined, then the advanced balancing features will be enabled
** for this version.
*/
//#define ADVANCED
#define PATCH // Super patch (1.17?)
/**********************************************************************
** The demo version of C&C will be built if the following define
** is active.
*/
//#define DEMO
/*
** Use AI pulled in from Red Alert. ST - 7/26/2019 11:42AM
*/
#define USE_RA_AI
/**********************************************************************
** Define this to allow play of the bonus missions for the Gateway
** bundle deal.
*/
#define BONUS_MISSIONS
/**********************************************************************
** Handle expansion scnearios as a set of single missions with all
** necessary information self contained within the mission file.
*/
#ifndef DEMO
#define NEWMENU
#endif
/**********************************************************************
** If the scenario editor to to be active in this build then uncomment
** the following #define line.
*/
//#define SCENARIO_EDITOR
/**********************************************************************
** This define enables the full set of cheat keys and special
** command line options.
*/
#define CHEAT_KEYS
/**********************************************************************
** 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.
*/
//#define VIRGIN_CHEAT_KEYS
/**********************************************************************
** Optional parameter control for special options.
*/
//#define PARM_6PLAYER 0x5D9F6F24 // "6"
#define PARM_6PLAYER 0x9CAFC93B // Alternate 6 player keyphrase.
/*
** 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
#define PARM_CHEATDAVID 0xBE79088C // Cheat keys for David Dettmer
#define PARM_CHEATERIK 0x9F38A19D // Cheat keys for Erik Yeo
#define PARM_EDITORERIK 0xC2AA509B // Map editor for Erik Yeo
#define PARM_CHEATPHIL 0x39D01821 // Cheat keys for Phil Gorrow
#define PARM_CHEATJOE 0xABDD0362 // Cheat keys for Joe Bostic
#define PARM_CHEATBILL 0xB5B63531 // Cheat keys for Bill Randolph
#define PARM_CHEAT_STEVET 0x2E7FE493 // Cheat keys for Steve Tall
#define PARM_EDITORBILL 0x7E7C4CCA // "-EDITOR"
#define PARM_CHEATMIKE 0x00532693 // Mike Lightner
#define PARM_CHEATADAM 0xDFABC23A // Adam Isgreen
#endif
//#define PARM_CHEAT 0x6F4BE7CA // "CHEAT"
//#define PARM_EDITOR 0x7E7C4CCA // "-EDITOR"
#define PARM_EASY 0x59E975CE // "EASY" Enables easy mode.
#define PARM_HARD 0xACFE9D13 // "HARD" Enables hard mode.
#define PARM_INSTALL 0xD95C68A2 // "FROMINSTALL"
#define PARM_TRUENAME 0xB1A34435 // Enables true object names.
#define PARM_3POINT 0x03552894 // Enable three point turns.
#define PARM_SCORE 0x7FDE2C33 // Enables alternate themes.
#define PARM_COMBAT 0xDC57C4B2 // Gives combat advantage to attacker.
#define PARM_TREETARGET 0x00AB6BEF // Allows targeting of trees without <CTRL> key.
#define PARM_BIB 0xF7867BF0 // Disables building bibs.
#define PARM_MCV 0x104DF10F // MCV undeploys rather than sells.
#define PARM_HELIPAD 0x53EBECBC // Helipad can be purchased separately from helicopter.
#define PARM_IQ 0x9E3881B8 // Smart self defense logic enable.
#define PARM_SQUISH 0x4EA2FBDF // Squish images for infantry bodies.
#define PARM_HUMAN 0xACB58F61 // Human generated sound effects.
#define PARM_SCROLLING 0xC084AE82 // Restricts scrolling over the tabs.
//#define PARM_SPECIAL 0xD18129F6 // Enables special mode.
//#define PARM_SPECIAL 0x2E84E394 // #1
//#define PARM_SPECIAL 0x63CE7584 // #2
//#define PARM_SPECIAL 0x85F110A5 // #3
///#define PARM_SPECIAL 0x7F65F13C // #4
//#define PARM_SPECIAL 0x431F5F61 // #5
#define PARM_SPECIAL 0x11CA05BB // #6 funpark
//#define PARM_SPECIAL 0xE0F651B9 // #7
//#define PARM_SPECIAL 0x10B9683D // #8
//#define PARM_SPECIAL 0xEE1CD37D // #9
/**********************************************************************
** Defines for verifying free disk space
*/
#define INIT_FREE_DISK_SPACE 1024*4096 //8388608
#define SAVE_GAME_DISK_SPACE INIT_FREE_DISK_SPACE // (INIT_FREE_DISK_SPACE - (1024*4096))
//#define SAVE_GAME_DISK_SPACE 100000
/**********************************************************************
** This is the credit threshold that the computer's money must exceed
** in order for structure repair to commence.
*/
#define REPAIR_THRESHHOLD 1000
//#define GERMAN 1
//#define FRENCH 1
//#define JAPANESE 1
#define FOREIGN_VERSION_NUMBER 6
//
// typedef enums with -1 will show this warning, even when the type of the enum is signed. It's a compiler bug, apparently
// ST - 1/8/2019 9:23AM
//
#pragma warning (push)
#pragma warning (disable:4341)
/**********************************************************************
** These enumerations are used to implement RTTI.
*/
typedef enum RTTIType : unsigned char {
RTTI_NONE=0,
RTTI_INFANTRY,
RTTI_INFANTRYTYPE,
RTTI_UNIT,
RTTI_UNITTYPE,
RTTI_AIRCRAFT,
RTTI_AIRCRAFTTYPE,
RTTI_BUILDING,
RTTI_BUILDINGTYPE,
RTTI_TERRAIN,
RTTI_ABSTRACTTYPE,
RTTI_ANIM,
RTTI_ANIMTYPE,
RTTI_BULLET,
RTTI_BULLETTYPE,
RTTI_OVERLAY,
RTTI_OVERLAYTYPE,
RTTI_SMUDGE,
RTTI_SMUDGETYPE,
RTTI_TEAM,
RTTI_TEMPLATE,
RTTI_TEMPLATETYPE,
RTTI_TERRAINTYPE,
RTTI_OBJECT,
RTTI_SPECIAL
} 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
/**********************************************************************
** 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
// Use this to allow keep track of versions as they affect saved games.
#define VERSION_NUMBER 1
#define RELEASE_NUMBER 01
#define FAME_FILE_NAME "HALLFAME.DAT"
/**********************************************************************
** Map controls. The map is composed of square elements called 'cells'.
** All larger elements are build upon these.
*/
// Size of the map in cells. The width of the map must be a power
// of two. This is accomplished by setting the width by the number of
// bits it occupies. The number of meta-cells will be a subset of the
// cell width.
#define MAP_CELL_MAX_X_BITS 6
#define MAP_CELL_MAX_Y_BITS 6
#define MAP_CELL_X_MASK (~(~0 << MAP_CELL_MAX_X_BITS))
//#define MAP_CELL_Y_MASK ((~(~0 << MAP_CELL_MAX_Y_BITS)) << MAP_CELL_MAX_Y_BITS)
// Size of the map in cells.
#define MAP_CELL_W (1<<MAP_CELL_MAX_X_BITS)
#define MAP_CELL_H (1<<MAP_CELL_MAX_Y_BITS)
#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.
/*
** 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)
/**********************************************************************
** 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, // Faile because unable to comply (busy or occupied).
} ProdFailType;
/**********************************************************************
** 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 : unsigned char {
SPC_NONE,
SPC_ION_CANNON, // Partical beam from satalite (Akira effect).
SPC_NUCLEAR_BOMB, // Tactical nuclear weapon.
SPC_AIR_STRIKE // Conventional air strike.
} SpecialWeaponType;
/**********************************************************************
** These defines control the rate of ion cannon and airstrike recharging.
*/
#define NUKE_GONE_TIME 14*TICKS_PER_MINUTE
#define ION_CANNON_GONE_TIME 10*TICKS_PER_MINUTE
#define AIR_CANNON_GONE_TIME 8*TICKS_PER_MINUTE
#define OBELISK_ANIMATION_RATE 15
/**********************************************************************
** 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_PICK_ANOTHER=-2,
THEME_NONE=-1,
THEME_AIRSTRIKE,
THEME_80MX,
THEME_CHRG,
THEME_CREP,
THEME_DRIL,
THEME_DRON,
THEME_FIST,
THEME_RECON,
THEME_VOICE,
THEME_HEAVYG,
THEME_J1,
THEME_JDI_V2,
THEME_RADIO,
THEME_RAIN,
THEME_AOI, // Act On Instinct
THEME_CCTHANG, // C&C Thang
THEME_DIE, // Die!!
THEME_FWP, // Fight, Win, Prevail
THEME_IND, // Industrial
THEME_IND2, // Industrial2
THEME_JUSTDOIT, // Just Do It!
THEME_LINEFIRE, // In The Line Of Fire
THEME_MARCH, // March To Your Doom
THEME_MECHMAN, // Mechanical Man
THEME_NOMERCY, // No Mercy
THEME_OTP, // On The Prowl
THEME_PRP, // Prepare For Battle
THEME_ROUT, // Reaching Out
THEME_HEART, //
THEME_STOPTHEM, // Stop Them
THEME_TROUBLE, // Looks Like Trouble
THEME_WARFARE, // Warfare
THEME_BFEARED, // Enemies To Be Feared
THEME_IAM, // I Am
THEME_WIN1, // Great Shot!
THEME_MAP1, // Map subliminal techno "theme".
THEME_VALKYRIE, // Ride of the valkyries.
THEME_COUNT,
THEME_LAST=THEME_BFEARED,
THEME_FIRST=0
} ThemeType;
//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?
} ThreatType;
//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 obect transitions between
** cloaked and uncloaked conditions.
*/
typedef enum CloakType : unsigned char {
UNCLOAKED, // Completely visible (normal state).
CLOAKING, // In process of claoking.
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_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_TIMED_HUNT, // Wait a while, then go into HUNT (multiplayer AI)
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_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_ION, // That target object should be blasted.
ACTION_NUKE_BOMB, // That target object should be blasted.
ACTION_AIR_STRIKE, // That target object should be blasted.
ACTION_GUARD_AREA, // Guard the area/object clicked on.
ACTION_TOGGLE_PRIMARY, // Toggle the primary status of the factory.
ACTION_NO_DEPLOY,
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;
/**********************************************************************
** 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 : char {
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
};
/**********************************************************************
** 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,
MPH_KINDA_SLOW=6,
MPH_SLOW=8,
MPH_SLOW_ISH=10,
MPH_MEDIUM_SLOW=12,
MPH_MEDIUM=18,
MPH_MEDIUM_FAST=30,
MPH_MEDIUM_FASTER=35,
MPH_FAST=40,
MPH_ROCKET=60,
MPH_VERY_FAST=100,
MPH_LIGHT_SPEED=255
} MPHType;
/**********************************************************************
** General audio volume is enumerated by these identifiers. Since small
** volume variations are usually unnoticable when specifying the volume
** to play a sample, this enumeration list creates more readable code.
*/
typedef enum VolType : unsigned char
{
VOL_OFF=0,
VOL_0=VOL_OFF,
VOL_1=0x19,
VOL_2=0x32,
VOL_3=0x4C,
VOL_4=0x66,
VOL_5=0x80,
VOL_6=0x9A,
VOL_7=0xB4,
VOL_8=0xCC,
VOL_9=0xE6,
VOL_10=0xFF,
VOL_FULL=VOL_10
} VolType;
/**********************************************************************
** The houses that can be played are listed here. Each has their own
** personality and strengths.
*/
typedef enum HousesType : char {
HOUSE_NONE=-1,
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_COUNT,
HOUSE_FIRST=HOUSE_GOOD
} HousesType;
//inline HousesType operator++(HousesType &, int);
#define HOUSEF_GOOD (1<<HOUSE_GOOD)
#define HOUSEF_BAD (1<<HOUSE_BAD)
#define HOUSEF_NEUTRAL (1<<HOUSE_NEUTRAL)
#define HOUSEF_JP (1<<HOUSE_JP)
#define HOUSEF_MULTI1 (1<<HOUSE_MULTI1)
#define HOUSEF_MULTI2 (1<<HOUSE_MULTI2)
#define HOUSEF_MULTI3 (1<<HOUSE_MULTI3)
#define HOUSEF_MULTI4 (1<<HOUSE_MULTI4)
#define HOUSEF_MULTI5 (1<<HOUSE_MULTI5)
#define HOUSEF_MULTI6 (1<<HOUSE_MULTI6)
typedef enum PlayerColorType : char {
REMAP_NONE = -1,
REMAP_GOLD,
REMAP_FIRST=REMAP_GOLD,
REMAP_LTBLUE,
REMAP_RED,
REMAP_GREEN,
REMAP_ORANGE,
REMAP_BLUE,
REMAP_LAST=REMAP_BLUE,
REMAP_COUNT
} PlayerColorType;
/**********************************************************************
** 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_GDI,
SCEN_PLAYER_NOD,
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);
/**********************************************************************
** 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_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;
//inline LayerType operator++(LayerType &, int);
/**********************************************************************
** This enumerates the various bullet types. These types specify bullet's
** visual and explosive characteristics.
*/
typedef enum BulletType : char {
BULLET_NONE=-1,
BULLET_SNIPER, // Sniper bullet.
BULLET_BULLET, // Small arms
BULLET_APDS, // Armor piercing projectile.
BULLET_HE, // High explosive shell.
BULLET_SSM, // Surface to surface small missile type.
BULLET_SSM2, // MLRS missile.
BULLET_SAM, // Fast homing anti-aircraft missile.
BULLET_TOW, // TOW anti-vehicle short range missile.
BULLET_FLAME, // Flame thrower flame.
BULLET_CHEMSPRAY, // Chemical weapon spray.
BULLET_NAPALM, // Napalm bomblet.
BULLET_GRENADE, // Hand tossed grenade.
BULLET_LASER, // Laser beam from obelisk
BULLET_NUKE_UP, // Nuclear Missile on its way down
BULLET_NUKE_DOWN, // Nuclear Missile on its way up
BULLET_HONEST_JOHN, // SSM with napalm warhead.
BULLET_SPREADFIRE, // Chain gun bullets.
BULLET_HEADBUTT, // Stegosaurus, Triceratops head butt
BULLET_TREXBITE, // Tyrannosaurus Rex's bite - especially bad for infantry
#ifdef PETROGLYPH_EXAMPLE_MOD
BULLET_NUKE_LOB, // Nuke projectile
#endif //PETROGLYPH_EXAMPLE_MOD
BULLET_COUNT,
BULLET_FIRST=0
} BulletType;
//inline BulletType operator++(BulletType &, int);
/**********************************************************************
** All game buildings (structures) are enumerated here. This includes
** civilian structures as well.
*/
typedef enum StructType : char {
STRUCT_NONE=-1,
STRUCT_WEAP,
STRUCT_GTOWER,
STRUCT_ATOWER,
STRUCT_OBELISK,
STRUCT_RADAR,
STRUCT_TURRET,
STRUCT_CONST,
STRUCT_REFINERY,
STRUCT_STORAGE,
STRUCT_HELIPAD,
STRUCT_SAM,
STRUCT_AIRSTRIP,
STRUCT_POWER,
STRUCT_ADVANCED_POWER,
STRUCT_HOSPITAL,
STRUCT_BARRACKS,
STRUCT_TANKER,
STRUCT_REPAIR,
STRUCT_BIO_LAB,
STRUCT_HAND,
STRUCT_TEMPLE,
STRUCT_EYE,
STRUCT_MISSION,
/*
** All buildings that are never used as a prerequisite
** for construction, follow this point. Typically, this is
** limited to civilian structures.
*/
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,
#ifdef OBSOLETE
STRUCT_ROAD,
#endif
STRUCT_SANDBAG_WALL,
STRUCT_CYCLONE_WALL,
STRUCT_BRICK_WALL,
STRUCT_BARBWIRE_WALL,
STRUCT_WOOD_WALL,
STRUCT_COUNT,
STRUCT_FIRST=0
} StructType;
//inline StructType operator++(StructType &, int);
#define STRUCTF_NONE 0L
#define STRUCTF_ADVANCED_POWER (1L << STRUCT_ADVANCED_POWER)
#define STRUCTF_REPAIR (1L << STRUCT_REPAIR)
#define STRUCTF_EYE (1L << STRUCT_EYE)
#define STRUCTF_TEMPLE (1L << STRUCT_TEMPLE)
#define STRUCTF_HAND (1L << STRUCT_HAND)
#define STRUCTF_BIO_LAB (1L << STRUCT_BIO_LAB)
#define STRUCTF_OBELISK (1L << STRUCT_OBELISK)
#define STRUCTF_ATOWER (1L << STRUCT_ATOWER)
#define STRUCTF_WEAP (1L << STRUCT_WEAP)
#define STRUCTF_GTOWER (1L << STRUCT_GTOWER)
#define STRUCTF_RADAR (1L << STRUCT_RADAR)
#define STRUCTF_TURRET (1L << STRUCT_TURRET)
#define STRUCTF_CIV1 (1L << STRUCT_CIV1)
#define STRUCTF_CIV2 (1L << STRUCT_CIV2)
#define STRUCTF_CIV3 (1L << STRUCT_CIV3)
#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_HOSPITAL (1L << STRUCT_HOSPITAL)
#define STRUCTF_BARRACKS (1L << STRUCT_BARRACKS)
#define STRUCTF_TANKER (1L << STRUCT_TANKER)
#define STRUCTF_MISSION (1L << STRUCT_MISSION)
/**********************************************************************
** 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_CONCRETE, // Concrete.
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_TIBERIUM1, // Tiberium patch.
OVERLAY_TIBERIUM2, // Tiberium patch.
OVERLAY_TIBERIUM3, // Tiberium patch.
OVERLAY_TIBERIUM4, // Tiberium patch.
OVERLAY_TIBERIUM5, // Tiberium patch.
OVERLAY_TIBERIUM6, // Tiberium patch.
OVERLAY_TIBERIUM7, // Tiberium patch.
OVERLAY_TIBERIUM8, // Tiberium patch.
OVERLAY_TIBERIUM9, // Tiberium patch.
OVERLAY_TIBERIUM10, // Tiberium patch.
OVERLAY_TIBERIUM11, // Tiberium patch.
OVERLAY_TIBERIUM12, // Tiberium patch.
OVERLAY_ROAD, // Road/concrete piece.
OVERLAY_SQUISH, // Squish mark for overran infantry.
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_COUNT,
OVERLAY_FIRST=0
} OverlayType;
//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_E5, // Chemical thrower equipped.
INFANTRY_E7, // Engineer.
INFANTRY_RAMBO, // Commando.
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_MOEBIUS, // Dr. Moebius
INFANTRY_DELPHI, // Agent "Delphi"
INFANTRY_CHAN, // Dr. Chan
INFANTRY_COUNT,
INFANTRY_FIRST=0
} InfantryType;
//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, // Heavy tank (Mammoth).
UNIT_MTANK, // Medium tank (M1).
UNIT_LTANK, // Light tank ('Bradly').
UNIT_STANK, // Stealth tank (Romulan).
UNIT_FTANK, // Flame thrower tank.
UNIT_VICE, // Visceroid
UNIT_APC, // APC.
UNIT_MLRS, // MLRS rocket launcher.
UNIT_JEEP, // 4x4 jeep replacement.
UNIT_BUGGY, // Rat patrol dune buggy type.
UNIT_HARVESTER, // Resource gathering vehicle.
UNIT_ARTY, // Artillery unit.
UNIT_MSAM, // Anti-Aircraft vehicle.
UNIT_HOVER, // Hovercraft.
UNIT_MHQ, // Mobile Head Quarters.
UNIT_GUNBOAT, // Gunboat
UNIT_MCV, // Mobile construction vehicle.
UNIT_BIKE, // Nod recon motor-bike.
UNIT_TRIC, // Triceratops
UNIT_TREX, // Tyranosaurus Rex
UNIT_RAPT, // Velociraptor
UNIT_STEG, // Stegasaurus
#ifdef PETROGLYPH_EXAMPLE_MOD
UNIT_NUKE_TANK, // Mammoth with a nuke
#endif
UNIT_COUNT,
UNIT_FIRST=0
} UnitType;
//inline UnitType operator++(UnitType &, int);
#define UNITF_HTANK (1L<<UNIT_HTANK)
#define UNITF_MTANK (1L<<UNIT_MTANK)
#define UNITF_LTANK (1L<<UNIT_LTANK)
#define UNITF_STANK (1L<<UNIT_STANK)
#define UNITF_FTANK (1L<<UNIT_FTANK)
#define UNITF_APC (1L<<UNIT_APC)
#define UNITF_MLRS (1L<<UNIT_MLRS)
#define UNITF_JEEP (1L<<UNIT_JEEP)
#define UNITF_BUGGY (1L<<UNIT_BUGGY)
#define UNITF_HARVESTER (1L<<UNIT_HARVESTER)
#define UNITF_ARTY (1L<<UNIT_ARTY)
#define UNITF_MSAM (1L<<UNIT_MSAM)
#define UNITF_HOVER (1L<<UNIT_HOVER)
#define UNITF_MHQ (1L<<UNIT_MHQ)
#define UNITF_GUNBOAT (1L<<UNIT_GUNBOAT)
#define UNITF_MCV (1L<<UNIT_MCV)
#define UNITF_BIKE (1L<<UNIT_BIKE)
#define UNITF_VICE (1L<<UNIT_VICE)
#define UNITF_TRIC (1L<<UNIT_TRIC)
#define UNITF_TREX (1L<<UNIT_TREX)
#define UNITF_RAPT (1L<<UNIT_RAPT)
#define UNITF_STEG (1L<<UNIT_STEG)
/**********************************************************************
** The variuos aircraft types are enumerated here. These include helicopters
** as well as traditional aircraft.
*/
typedef enum AircraftType : char {
AIRCRAFT_TRANSPORT, // Transport helicopter.
AIRCRAFT_A10, // Ground attack plane.
AIRCRAFT_HELICOPTER, // Apache gunship.
AIRCRAFT_CARGO, // Cargo plane.
AIRCRAFT_ORCA, // Nod attack helicopter.
AIRCRAFT_COUNT,
AIRCRAFT_NONE=-1,
AIRCRAFT_FIRST=0
} AircraftType;
#define AIRCRAFTF_TRANSPORT (1L << AIRCRAFT_TRANSPORT)
#define AIRCRAFTF_A10 (1L << AIRCRAFT_A10)
#define AIRCRAFTF_HELICOPTER (1L << AIRCRAFT_HELICOPTER)
#define AIRCRAFTF_CARGO (1L << AIRCRAFT_CARGO)
#define AIRCRAFTF_ORCA (1L << AIRCRAFT_ORCA)
//inline AircraftType operator++(AircraftType &, int);
/**********************************************************************
** The game templates are enumerated here. These are the underlying
** terrain art. This includes everything from water to clifs. 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 char {
TEMPLATE_CLEAR1,
TEMPLATE_WATER, // This must be the first non-clear template.
TEMPLATE_WATER2,
TEMPLATE_SHORE1,
TEMPLATE_SHORE2,
TEMPLATE_SHORE3,
TEMPLATE_SHORE4,
TEMPLATE_SHORE5,
TEMPLATE_SHORE11,
TEMPLATE_SHORE12,
TEMPLATE_SHORE13,
TEMPLATE_SHORE14,
TEMPLATE_SHORE15,
TEMPLATE_SLOPE1,
TEMPLATE_SLOPE2,
TEMPLATE_SLOPE3,
TEMPLATE_SLOPE4,
TEMPLATE_SLOPE5,
TEMPLATE_SLOPE6,
TEMPLATE_SLOPE7,
TEMPLATE_SLOPE8,
TEMPLATE_SLOPE9,
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_SHORE32,
TEMPLATE_SHORE33,
TEMPLATE_SHORE20,
TEMPLATE_SHORE21,
TEMPLATE_SHORE22,
TEMPLATE_SHORE23,
TEMPLATE_BRUSH1,
TEMPLATE_BRUSH2,
TEMPLATE_BRUSH3,
TEMPLATE_BRUSH4,
TEMPLATE_BRUSH5,
TEMPLATE_BRUSH6,
TEMPLATE_BRUSH7,
TEMPLATE_BRUSH8,
TEMPLATE_BRUSH9,
TEMPLATE_BRUSH10,
TEMPLATE_PATCH1,
TEMPLATE_PATCH2,
TEMPLATE_PATCH3,
TEMPLATE_PATCH4,
TEMPLATE_PATCH5,
TEMPLATE_PATCH6,
TEMPLATE_PATCH7,
TEMPLATE_PATCH8,
TEMPLATE_SHORE16,
TEMPLATE_SHORE17,
TEMPLATE_SHORE18,
TEMPLATE_SHORE19,
TEMPLATE_PATCH13,
TEMPLATE_PATCH14,
TEMPLATE_PATCH15,
TEMPLATE_BOULDER1,
TEMPLATE_BOULDER2,
TEMPLATE_BOULDER3,
TEMPLATE_BOULDER4,
TEMPLATE_BOULDER5,
TEMPLATE_BOULDER6,
TEMPLATE_SHORE6,
TEMPLATE_SHORE7,
TEMPLATE_SHORE8,
TEMPLATE_SHORE9,
TEMPLATE_SHORE10,
TEMPLATE_ROAD1,
TEMPLATE_ROAD2,
TEMPLATE_ROAD3,
TEMPLATE_ROAD4,
TEMPLATE_ROAD5,
TEMPLATE_ROAD6,
TEMPLATE_ROAD7,
TEMPLATE_ROAD8,
TEMPLATE_ROAD9,
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_RIVER1,
TEMPLATE_RIVER2,
TEMPLATE_RIVER3,
TEMPLATE_RIVER4,
TEMPLATE_RIVER5,
TEMPLATE_RIVER6,
TEMPLATE_RIVER7,
TEMPLATE_RIVER8,
TEMPLATE_RIVER9,
TEMPLATE_RIVER10,
TEMPLATE_RIVER11,
TEMPLATE_RIVER12,
TEMPLATE_RIVER13,
TEMPLATE_RIVER14,
TEMPLATE_RIVER15,
TEMPLATE_RIVER16,
TEMPLATE_RIVER17,
TEMPLATE_RIVER18,
TEMPLATE_RIVER19,
TEMPLATE_RIVER20,
TEMPLATE_RIVER21,
TEMPLATE_RIVER22,
TEMPLATE_RIVER23,
TEMPLATE_RIVER24,
TEMPLATE_RIVER25,
TEMPLATE_FORD1,
TEMPLATE_FORD2,
TEMPLATE_FALLS1,
TEMPLATE_FALLS2,
TEMPLATE_BRIDGE1,
TEMPLATE_BRIDGE1D,
TEMPLATE_BRIDGE2,
TEMPLATE_BRIDGE2D,
TEMPLATE_BRIDGE3,
TEMPLATE_BRIDGE3D,
TEMPLATE_BRIDGE4,
TEMPLATE_BRIDGE4D,
TEMPLATE_SHORE24,
TEMPLATE_SHORE25,
TEMPLATE_SHORE26,
TEMPLATE_SHORE27,
TEMPLATE_SHORE28,
TEMPLATE_SHORE29,
TEMPLATE_SHORE30,
TEMPLATE_SHORE31,
TEMPLATE_PATCH16,
TEMPLATE_PATCH17,
TEMPLATE_PATCH18,
TEMPLATE_PATCH19,
TEMPLATE_PATCH20,
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_SHORE57,
TEMPLATE_SHORE58,
TEMPLATE_SHORE59,
TEMPLATE_SHORE60,
TEMPLATE_SHORE61,
TEMPLATE_SHORE62,
TEMPLATE_SHORE63,
TEMPLATE_COUNT,
TEMPLATE_NONE=255,
TEMPLATE_FIRST=0
} TemplateType;
//inline TemplateType operator++(TemplateType &, int);
/**********************************************************************
** 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_TREE4,
TERRAIN_TREE5,
TERRAIN_TREE6,
TERRAIN_TREE7,
TERRAIN_TREE8,
TERRAIN_TREE9,
TERRAIN_TREE10,
TERRAIN_TREE11,
TERRAIN_TREE12,
TERRAIN_TREE13,
TERRAIN_TREE14,
TERRAIN_TREE15,
TERRAIN_TREE16,
TERRAIN_TREE17,
TERRAIN_TREE18,
TERRAIN_BLOSSOMTREE1,
TERRAIN_BLOSSOMTREE2,
TERRAIN_CLUMP1,
TERRAIN_CLUMP2,
TERRAIN_CLUMP3,
TERRAIN_CLUMP4,
TERRAIN_CLUMP5,
TERRAIN_ROCK1,
TERRAIN_ROCK2,
TERRAIN_ROCK3,
TERRAIN_ROCK4,
TERRAIN_ROCK5,
TERRAIN_ROCK6,
TERRAIN_ROCK7,
TERRAIN_COUNT,
TERRAIN_FIRST=0
} TerrainType;
//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 terrin. 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;
//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=0, // Large fireball explosion (bulges rightward).
ANIM_GRENADE, // Genade (dirt type) explosion.
ANIM_FRAG1, // Medium fragment throwing explosion -- short decay.
ANIM_FRAG2, // Medium fragment throwing explosion -- long 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_FLAME_N, // Flame thrower firing north.
ANIM_FLAME_NE, // Flame thrower firing north east.
ANIM_FLAME_E, // Flame thrower firing east.
ANIM_FLAME_SE, // Flame thrower firing south east.
ANIM_FLAME_S, // Flame thrower firing south.
ANIM_FLAME_SW, // Flame thrower firing south west.
ANIM_FLAME_W, // Flame thrower firing west.
ANIM_FLAME_NW, // Flame thrower firing north west.
ANIM_CHEM_N, // Chem sprayer firing north.
ANIM_CHEM_NE, // Chem sprayer firing north east.
ANIM_CHEM_E, // Chem sprayer firing east.
ANIM_CHEM_SE, // Chem sprayer firing south east.
ANIM_CHEM_S, // Chem sprayer firing south.
ANIM_CHEM_SW, // Chem sprayer firing south west.
ANIM_CHEM_W, // Chem sprayer firing west.
ANIM_CHEM_NW, // Chem sprayer firing north west.
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).
#ifdef NEVER
ANIM_E1_ROT_FIRE, // Infantry decay animations.
ANIM_E1_ROT_GRENADE,
ANIM_E1_ROT_GUN,
ANIM_E1_ROT_EXP,
ANIM_E2_ROT_FIRE,
ANIM_E2_ROT_GRENADE,
ANIM_E2_ROT_GUN,
ANIM_E2_ROT_EXP,
ANIM_E3_ROT_FIRE,
ANIM_E3_ROT_GRENADE,
ANIM_E3_ROT_GUN,
ANIM_E3_ROT_EXP,
ANIM_E4_ROT_FIRE,
ANIM_E4_ROT_GRENADE,
ANIM_E4_ROT_GUN,
ANIM_E4_ROT_EXP,
#endif
ANIM_SMOKE_M, // Smoke rising from ground.
ANIM_BURN_SMALL, // Small combustable fire effect (with trail off).
ANIM_BURN_MED, // Medium combustable fire effect (with trail off).
ANIM_BURN_BIG, // Large combustable 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_ION_CANNON,
ANIM_ATOM_BLAST,
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_ATOM_DOOR,
ANIM_MOVE_FLASH,
ANIM_OILFIELD_BURN,
ANIM_TRIC_DIE,
ANIM_TREX_DIE,
ANIM_STEG_DIE,
ANIM_RAPT_DIE,
ANIM_CHEM_BALL, // Chemical warrior explosion.
ANIM_FLAG, // CTF flag.
ANIM_BEACON, // Beacon.
ANIM_FIRE_SMALL_VIRTUAL, // Small flame animation (virtual).
ANIM_FIRE_MED_VIRTUAL, // Medium flame animation (virtual).
ANIM_FIRE_MED2_VIRTUAL, // Medium flame animation (oranger) (virtual).
ANIM_FIRE_TINY_VIRTUAL, // Very tiny flames (virtual).
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_ON_GUARD,
DO_FIGHT_READY,
DO_PUNCH,
DO_KICK,
DO_PUNCH_HIT1,
DO_PUNCH_HIT2,
DO_PUNCH_DEATH,
DO_KICK_HIT1,
DO_KICK_HIT2,
DO_KICK_DEATH,
DO_READY_WEAPON,
DO_GUN_DEATH,
DO_EXPLOSION_DEATH,
DO_EXPLOSION2_DEATH,
DO_GRENADE_DEATH,
DO_FIRE_DEATH,
DO_GESTURE1,
DO_SALUTE1,
DO_GESTURE2,
DO_SALUTE2,
// Civilian actions
DO_PULL_GUN,
DO_PLEAD,
DO_PLEAD_DEATH,
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."
// Hand to hand combat messages (yelled rather than radioed).
RADIO_KICK, // "Take this kick, you.. you.."
RADIO_PUNCH, // "Take this punch, you.. you.."
RADIO_PREPARE_TO_BOX,// "Fancy a little fisticuffs, eh?"
RADIO_NEED_REPAIR, // "Are you in need of service depot work?"
RADIO_ON_DEPOT, // "Are you sitting on a service depot?"
RADIO_COUNT
} RadioMessageType;
/****************************************************************************
** These are custom C&C specific types. The CELL is used for map coordinate
** with cell resolution. The COORD type is used for map coordinates that
** have a lepton resolution.
*/
typedef unsigned long COORDINATE;
typedef signed short CELL;
typedef unsigned short TARGET;
#define TARGET_NONE ((TARGET)0)
/****************************************************************************
** 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.
} 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 : 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_ION_CANNON,
MOUSE_NUCLEAR_BOMB,
MOUSE_AIR_STRIKE,
MOUSE_DEMOLITIONS,
MOUSE_AREA_GUARD,
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_BLUE_UP, // Raised blue border.
BOXSTYLE_DIS_DOWN, // Disabled but depressed.
BOXSTYLE_DIS_RAISED, // Disabled but raised.
BOXSTYLE_RAISED_ARROW, // Typical raised edge w/arrow around caption
BOXSTYLE_GREEN_DOWN, // green depressed edge border.
BOXSTYLE_GREEN_RAISED, // green raised edge border.
BOXSTYLE_GREEN_DIS_DOWN, // disabled but depressed.
BOXSTYLE_GREEN_DIS_RAISED, // disabled but raised.
BOXSTYLE_GREEN_BOX, // list box.
BOXSTYLE_GREEN_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, // Amor piercing -- good against armor.
WARHEAD_FIRE, // Incendiary -- Good against flammables.
WARHEAD_LASER, // Light Amplification of Stimulated Emission of Radiation.
WARHEAD_PB, // Particle beam (neutron beam).
WARHEAD_FIST, // punching in hand-to-hand combat
WARHEAD_FOOT, // kicking in hand-to-hand combat
WARHEAD_HOLLOW_POINT, // Sniper bullet type.
WARHEAD_SPORE, // Spores from blossom tree - affect infantry only
WARHEAD_HEADBUTT, // Other dinosaurs butt into people
WARHEAD_FEEDME, // T-Rex eats people, hurts vehicles/buildings
WARHEAD_COUNT
} 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_RIFLE,
WEAPON_CHAIN_GUN,
WEAPON_PISTOL,
WEAPON_M16,
WEAPON_DRAGON,
WEAPON_FLAMETHROWER,
WEAPON_FLAME_TONGUE,
WEAPON_CHEMSPRAY,
WEAPON_GRENADE,
WEAPON_75MM,
WEAPON_105MM,
WEAPON_120MM,
WEAPON_TURRET_GUN,
WEAPON_MAMMOTH_TUSK,
WEAPON_MLRS,
WEAPON_155MM,
WEAPON_M60MG,
WEAPON_TOMAHAWK,
WEAPON_TOW_TWO,
WEAPON_NAPALM,
WEAPON_OBELISK_LASER,
WEAPON_NIKE,
WEAPON_HONEST_JOHN,
WEAPON_STEG,
WEAPON_TREX,
#ifdef PETROGLYPH_EXAMPLE_MOD
WEAPON_NUKE_LOB,
#endif PETROGLYPH_EXAMPLE_MOD
WEAPON_COUNT
} 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
} ArmorType;
/**********************************************************************
** Working MCGA colors that give a pleasing effect for beveled edges and
** other purposes.
*/
#define MAGIC_COL_COUNT 12 // 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 32
#define CYCLE_COLOR_COUNT 7
/**********************************************************************
** Magic color fading pulsing effect limts -- color gun value.
*/
#define MIN_CYCLE_COLOR 16
#define MAX_CYCLE_COLOR 63
/**********************************************************************
** The game's six and eight point fonts have these names.
*/
#define FONT3 "3point.fnt"
#define FONT6 "6point.fnt"
#define FONT8 "8point.fnt"
/**********************************************************************
** 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, // Use 6 point gradient font.
TPF_GREEN12 =0x0008, // Use green tab font
TPF_GREEN12_GRAD =0x0009, // Use graduated green tab 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;
//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));}
/**********************************************************************
** 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 AIRCRAFT_MAX 100 // Lasts for minutes.
#define ANIM_MAX 200 // Lasts only a few seconds.
#define BUILDING_MAX 500 // Lasts for hours.
#define BULLET_MAX 50 // Lasts several seconds.
#define FACTORY_MAX 32 // Lasts a few minutes.
#define HOUSE_MAX 12 // Lasts entire scenario.
#define INFANTRY_MAX 500 // Lasts for minutes.
#define OVERLAY_MAX 1 // Very transitory.
#define REINFORCEMENT_MAX 50 // Maximum number of reinforcements.
#define SMUDGE_MAX 1 // Very transitory.
#define TEAM_MAX 60 // Lasts forever.
#define TEMPLATE_MAX 1 // Very transitory.
#define TERRAIN_MAX 500 // Lasts for hours or eternity.
#define TRIGGER_MAX 80 // Lasts forever.
#define UNIT_MAX 500 // Lasts for minutes.
#define TEAMTYPE_MAX 60 // Lasts forever.
// Save filename description.
#define DESCRIP_MAX 44 // 40 chars + CR + LF + CTRL-Z + NULL
#define MAX_ENTRY_SIZE 15
#define OBUTTON_HEIGHT 9 // Is defined in mapedit.h, need for buttons
#define CONQUER_PATH_MAX 9 // Number of cells to look ahead for movement.
#define EACH_UNIT_MAX (UNIT_MAX/4) // Default maximum any one player can have.
#define EACH_BUILDING_MAX (BUILDING_MAX/4) // 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 : unsigned 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_COUNT
} LandType;
/**********************************************************************
** The theaters of operation are as follows.
*/
typedef enum TheaterType : char {
THEATER_NONE=-1,
THEATER_DESERT,
THEATER_JUNGLE,
THEATER_TEMPERATE,
THEATER_WINTER,
THEATER_COUNT,
THEATER_FIRST=0
} TheaterType;
//inline TheaterType operator++(TheaterType &, int);
#define THEATERF_DESERT (1<<THEATER_DESERT)
#define THEATERF_JUNGLE (1<<THEATER_JUNGLE)
#define THEATERF_TEMPERATE (1<<THEATER_TEMPERATE)
#define THEATERF_WINTER (1<<THEATER_WINTER)
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_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_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);
}
typedef enum DirType : unsigned char {
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=254
} 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);
}
/****************************************************************************
** 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 TICKS_PER_SECOND 15
#define TICKS_PER_MINUTE (TICKS_PER_SECOND * 60)
#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)
/****************************************************************************
** 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=0, // Bipedal.
SPEED_TRACK, // Tracked locomotion.
SPEED_HARVESTER, // Harvester speed rating.
SPEED_WHEEL, // Balloon tires.
SPEED_WINGED, // Lifter's, 'thopters, and rockets.
SPEED_HOVER, // Typical hovercraft logic.
SPEED_FLOAT, // Ships.
SPEED_COUNT,
SPEED_FIRST=SPEED_FOOT
} SpeedType;
/**********************************************************************
** These are the sound effect digitized sample file names.
*/
typedef enum VocType : char{
VOC_NONE=-1,
VOC_RAMBO_PRESENT,// "I've got a present for ya"
VOC_RAMBO_CMON, // "c'mon"
VOC_RAMBO_UGOTIT, // "you got it"
VOC_RAMBO_COMIN, // "keep 'em commin'"
VOC_RAMBO_LAUGH, // "hahaha"
VOC_RAMBO_LEFTY, // "that was left handed"
VOC_RAMBO_NOPROB, // "no problem"
// VOC_RAMBO_OHSH, // "oh shiiiiii...."
VOC_RAMBO_ONIT, // "I'm on it"
VOC_RAMBO_YELL, // "ahhhhhhh"
VOC_RAMBO_ROCK, // "time to rock and roll"
VOC_RAMBO_TUFF, // "real tuff guy"
VOC_RAMBO_YEA, // "yea"
VOC_RAMBO_YES, // "yes"
VOC_RAMBO_YO, // "yo"
VOC_GIRL_OKAY, // "okay"
VOC_GIRL_YEAH, // "yeah?"
VOC_GUY_OKAY, // "okay"
VOC_GUY_YEAH, // "yeah?"
VOC_2DANGER, // "negative, too dangerous"
VOC_ACKNOWL, // "acknowledged"
VOC_AFFIRM, // "affirmative"
VOC_AWAIT, // "awaiting orders"
// VOC_BACKUP, // "send backup"
// VOC_HELP, // "send help"
VOC_MOVEOUT, // "movin' out"
VOC_NEGATIVE, // "negative"
VOC_NO_PROB, // "not a problem"
VOC_READY, // "ready and waiting"
VOC_REPORT, // "reporting"
VOC_RIGHT_AWAY, // "right away sir"
VOC_ROGER, // "roger"
// VOC_SIR, // "sir?"
// VOC_SQUAD, // "squad reporting"
// VOC_PRACTICE, // "target practice"
VOC_UGOTIT, // "you got it"
VOC_UNIT, // "unit reporting"
VOC_VEHIC, // "vehicle reporting"
VOC_YESSIR, // "yes sir"
VOC_BAZOOKA, // Gunfire
VOC_BLEEP, // Clean metal bing
VOC_BOMB1, // Crunchy parachute bomb type explosion
VOC_BUTTON, // Dungeon Master button click
VOC_RADAR_ON, // Elecronic static with beeps
VOC_CONSTRUCTION, // construction sounds
VOC_CRUMBLE, // muffled crumble sound
VOC_FLAMER1, // flame thrower
VOC_RIFLE, // rifle shot
VOC_M60, // machine gun burst -- 6 rounds
VOC_GUN20, // bat hitting heavy metal door
VOC_M60A, // medium machine gun burst
VOC_MINI, // mini gun burst
VOC_RELOAD, // gun clip reload
VOC_SLAM, // metal plates slamming together
VOC_HVYGUN10, // loud sharp cannon
VOC_ION_CANNON, // partical beam
VOC_MGUN11, // alternate tripple burst
VOC_MGUN2, // M-16 tripple burst
VOC_NUKE_FIRE, // long missile sound
VOC_NUKE_EXPLODE, // long but not loud explosion
VOC_LASER, // humming laser beam
VOC_LASER_POWER, // warming up sound of laser beam
VOC_RADAR_OFF, // doom door slide
VOC_SNIPER, // silenced rifle fire
VOC_ROCKET1, // rocket launch variation #1
VOC_ROCKET2, // rocket launch variation #2
VOC_MOTOR, // dentists drill
VOC_SCOLD, // cannot perform action feedback tone
VOC_SIDEBAR_OPEN, // xylophone clink
VOC_SIDEBAR_CLOSE,// xylophone clink
VOC_SQUISH2, // crushing infantry
VOC_TANK1, // sharp tank fire with recoil
VOC_TANK2, // sharp tank fire
VOC_TANK3, // sharp tank fire
VOC_TANK4, // big gun tank fire
VOC_UP, // credits counting up
VOC_DOWN, // credits counting down
VOC_TARGET, // target sound
VOC_SONAR, // sonar echo
VOC_TOSS, // air swish
VOC_CLOAK, // stealth tank
VOC_BURN, // burning crackle
VOC_TURRET, // muffled gunfire
VOC_XPLOBIG4, // very long muffled explosion
VOC_XPLOBIG6, // very long muffled explosion
VOC_XPLOBIG7, // very long muffled explosion
VOC_XPLODE, // long soft muffled explosion
VOC_XPLOS, // short crunchy explosion
VOC_XPLOSML2, // muffled mechanical explosion
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_SCREAM12, // short infantry scream
VOC_YELL1, // long infantry scream
VOC_YES, // "Yes?"
VOC_COMMANDER, // "Commander?"
VOC_HELLO, // "Hello?"
VOC_HMMM, // "Hmmm?"
// VOC_PROCEED1, // "I will proceed, post haste."
// VOC_PROCEED2, // "I will proceed, at once."
// VOC_PROCEED3, // "I will proceed, immediately."
// VOC_EXCELLENT1, // "That is an excellent plan."
// VOC_EXCELLENT2, // "Yes, that is an excellent plan."
VOC_EXCELLENT3, // "A wonderful plan."
// VOC_EXCELLENT4, // "Asounding plan of action commander."
// VOC_EXCELLENT5, // "Remarkable contrivance."
VOC_OF_COURSE, // "Of course."
VOC_YESYES, // "Yes yes yes."
VOC_QUIP1, // "Mind the Tiberium."
// VOC_QUIP2, // "A most remarkable Metasequoia Glyptostroboides."
VOC_THANKS, // "Thank you."
VOC_CASHTURN, // Sound of money being piled up.
VOC_BLEEPY3, // Clean computer bleep sound.
VOC_DINOMOUT, // Movin' out in dino-speak.
VOC_DINOYES, // Yes Sir in dino-speak.
VOC_DINOATK1, // Dino attack sound.
VOC_DINODIE1, // Dino die sound.
VOC_BEACON, // Beacon sound.
#ifdef PETROGLYPH_EXAMPLE_MOD
VOC_NUKE_LOB, // Modded unit firing sound
#endif
VOC_COUNT,
VOC_BUILD_SELECT=VOC_TARGET,
VOC_FIRST=0
} VocType;
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_DEAD_GDI, // GDI unit destroyed
VOX_DEAD_NOD, // Nod unit destroyed
VOX_DEAD_CIV, // civilian killed
// VOX_AFFIRMATIVE, // affirmative
// VOX_NEGATIVE, // negative
// VOX_UPGRADE_UNIT, // upgrade complete, new unit available
// VOX_UPGRADE_STRUCT, // upgrade complete, new structure available
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_NO_POWER, // insufficient power
VOX_NEED_MO_MONEY, // need more funds
VOX_BASE_UNDER_ATTACK, // our base is under attack
VOX_INCOMING_MISSILE, // incoming missile
VOX_ENEMY_PLANES, // enemy planes approaching
VOX_INCOMING_NUKE, // nuclear warhead approaching - "NUKE1"
// VOX_RADIATION_OK, // radiation levels are acceptable
// VOX_RADIATION_FATAL, // radiation levels are fatal
VOX_UNABLE_TO_BUILD, // unable to build more
VOX_PRIMARY_SELECTED, // primary building selected
// VOX_REPAIRS_COMPLETE, // repairs completed
VOX_NOD_CAPTURED, // Nod building captured
VOX_GDI_CAPTURED, // GDI building captured
// VOX_STRUCTURE_SOLD, // structure sold
VOX_ION_CHARGING, // ion cannon charging
VOX_ION_READY, // ion cannon ready
VOX_NUKE_AVAILABLE, // nuclear weapon available
VOX_NUKE_LAUNCHED, // nuclear weapon launched - "NUKLNCH1"
VOX_UNIT_LOST, // unit lost
VOX_STRUCTURE_LOST, // structure lost
VOX_NEED_HARVESTER, // need harvester
VOX_SELECT_TARGET, // select target
VOX_AIRSTRIKE_READY, // airstrike ready
VOX_NOT_READY, // not ready
VOX_TRANSPORT_SIGHTED, // Nod transport sighted
VOX_TRANSPORT_LOADED, // Nod transport loaded
VOX_PREPARE, // enemy approaching
VOX_NEED_MO_CAPACITY, // silos needed
VOX_SUSPENDED, // on hold
VOX_REPAIRING, // repairing
VOX_ENEMY_STRUCTURE, // enemy structure destroyed
VOX_GDI_STRUCTURE, // GDI structure destroyed
VOX_NOD_STRUCTURE, // NOD structure destroyed
VOX_ENEMY_UNIT, // Enemy unit destroyed.
// VOX_GOLD_UNIT, // gold unit destroyed
// VOX_GOLD_STRUCTURE, // gold structure destroyed
// VOX_GOLD_ONLINE, // gold player online
// VOX_GOLD_OFFLINE, // gold player has departed
// VOX_GOLD_LOST, // gold player destroyed
// VOX_GOLD_WON, // gold player is victorious
// VOX_RED_UNIT, // red unit destroyed
// VOX_RED_STRUCTURE, // red structure destroyed
// VOX_RED_ONLINE, // red player online
// VOX_RED_OFFLINE, // red player has departed
// VOX_RED_LOST, // red player destroyed
// VOX_RED_WON, // red player is victorious
// VOX_GREY_UNIT, // grey unit destroyed
// VOX_GREY_STRUCTURE, // grey structure destroyed
// VOX_GREY_ONLINE, // grey player online
// VOX_GREY_OFFLINE, // grey player has departed
// VOX_GREY_LOST, // grey player destroyed
// VOX_GREY_WON, // grey player is victorious
// VOX_ORANGE_UNIT, // orange unit destroyed
// VOX_ORANGE_STRUCTURE, // orange structure destroyed
// VOX_ORANGE_ONLINE, // orange player online
// VOX_ORANGE_OFFLINE, // orange player has departed
// VOX_ORANGE_LOST, // orange player destroyed
// VOX_ORANGE_WON, // orange player is victorious
// VOX_GREEN_UNIT, // green unit destroyed
// VOX_GREEN_STRUCTURE, // green structure destroyed
// VOX_GREEN_ONLINE, // green player online
// VOX_GREEN_OFFLINE, // green player has departed
// VOX_GREEN_LOST, // green player destroyed
// VOX_GREEN_WON, // green player is victorious
// VOX_BLUE_UNIT, // blue unit destroyed
// VOX_BLUE_STRUCTURE, // blue structure destroyed
// VOX_BLUE_ONLINE, // blue player online
// VOX_BLUE_OFFLINE, // blue player has departed
// VOX_BLUE_LOST, // blue player destroyed
// VOX_BLUE_WON, // blue player is victorious
VOX_COUNT,
// VOX_MULTI_UNIT = VOX_GOLD_UNIT,
// VOX_MULTI_STRUCTURE = VOX_GOLD_STRUCTURE,
// VOX_MULTI_ONLINE = VOX_GOLD_ONLINE,
// VOX_MULTI_OFFLINE = VOX_GOLD_OFFLINE,
// VOX_MULTI_LOST = VOX_GOLD_LOST,
// VOX_MULTI_WON = VOX_GOLD_WON,
VOX_FIRST=0
} VoxType;
#define NUM_MULTI_VOICES 6
/****************************************************************************
** 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_FIRST=0,
SOURCE_NORTH=SOURCE_FIRST, // From north edge.
SOURCE_EAST, // From east edge.
SOURCE_SOUTH, // From south edge.
SOURCE_WEST, // From west edge.
SOURCE_SHIPPING, // Shipping lane.
SOURCE_BEACH, // Selects beach to land upon.
SOURCE_AIR, // Dropped by air (someplace).
SOURCE_VISIBLE, // Dropped where player can see.
SOURCE_ENEMYBASE, // Dropped at enemy base.
SOURCE_HOMEBASE, // Dropped at friendly base.
SOURCE_OCEAN, // Enters from ocean map edge.
SOURCE_COUNT
} SourceType;
/****************************************************************************
** 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 {
int Color; // Radar map (map editor) id color.
unsigned char 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 = 26, // Home-cell for this scenario
WAYPT_REINF, // cell where reinforcements arrive
WAYPT_COUNT,
} WaypointType;
/****************************************************************************
** Max # of players total, including the game's owner
*/
#define MAX_PLAYERS 6
/****************************************************************************
** These are the possible types of multiplayer games supported.
*/
typedef enum GameEnum : unsigned char {
GAME_NORMAL, // not multiplayer
GAME_MODEM, // modem game
GAME_NULL_MODEM, // NULL-modem
GAME_IPX, // IPX Network game
GAME_INTERNET, // WInsock game
GAME_GLYPHX_MULTIPLAYER // Multiplayer game controlled by the GLYPHX engine. ST - 3/12/2019 10:04AM
} GameType;
#define MPLAYER_BUILD_LEVEL_MAX 7
/****************************************************************************
** This is the max character length of a player's name
*/
#define MPLAYER_NAME_MAX 12
/****************************************************************************
** Max # of colors for multiplayer games
*/
#define MAX_MPLAYER_COLORS 6
/****************************************************************************
** This defines the various possible communications protocols.
*/
typedef enum CommProtocolEnum : unsigned char {
COMM_PROTOCOL_SINGLE_NO_COMP = 0, // single frame with no compression
COMM_PROTOCOL_SINGLE_E_COMP, // single frame with event compression
COMM_PROTOCOL_MULTI_E_COMP, // multiple frame with event compression
COMM_PROTOCOL_COUNT,
DEFAULT_COMM_PROTOCOL = COMM_PROTOCOL_SINGLE_NO_COMP,
} CommProtocolType;
/****************************************************************************
** Min value for MaxAhead, for both net & modem; only applies for
** COMM_PROTOCOL_MULTI_E_COMP.
*/
#define MODEM_MIN_MAX_AHEAD 5
#define NETWORK_MIN_MAX_AHEAD 2
/****************************************************************************
** Max length of inter-player message buffers. Messages.Init() should specify
** a value <= this. For editing messages, the "to" field length is added to
** this length to generate the entire editable message length. For displayed
** messages, a "From" prefix length should be added to this value to generate
** the entire max displayable message length.
*/
#define COMPAT_MESSAGE_LENGTH 28
#define MAX_MESSAGE_SEGMENTS 3
#define MAX_MESSAGE_LENGTH COMPAT_MESSAGE_LENGTH*3
/*
** Defines for magic numbers to place in messages to allow concatenation.
*/
#define MESSAGE_HEAD_MAGIC_NUMBER 0xFACE
#define MESSAGE_TAIL_MAGIC_MUMBER 0xECAF
/*
** Max # of allowed messages at one time
*/
#define MAX_NUM_MESSAGES 10
#define PORTBUF_MAX 64 // Dialog field size
#define IRQBUF_MAX 3
#define BAUDBUF_MAX 7
#define INITSTRBUF_MAX 41
#define CWAITSTRBUF_MAX 16
#define CREDITSBUF_MAX 5
#define MODEM_NAME_MAX PORTBUF_MAX - 1 // Max length of modem name in list box
typedef enum DetectPortType : unsigned char {
PORT_VALID = 0,
PORT_INVALID,
PORT_IRQ_INUSE
} DetectPortType;
typedef enum DialStatusType : unsigned char {
DIAL_CONNECTED = 0,
DIAL_NO_CARRIER,
DIAL_BUSY,
DIAL_ERROR,
DIAL_NO_DIAL_TONE,
DIAL_CANCELED
} DialStatusType;
typedef enum DialMethodType : unsigned char {
DIAL_TOUCH_TONE = 0,
DIAL_PULSE,
DIAL_METHODS
} DialMethodType;
typedef enum CallWaitStringType : unsigned char {
CALL_WAIT_TONE_1 = 0,
CALL_WAIT_TONE_2,
CALL_WAIT_PULSE,
CALL_WAIT_CUSTOM,
CALL_WAIT_STRINGS_NUM
} CallWaitStringType;
/****************************************************************************
** This structure defines the settings for the serial port.
*/
typedef struct {
int Port;
int IRQ;
int Baud;
DialMethodType DialMethod;
int InitStringIndex;
int CallWaitStringIndex;
char CallWaitString[ CWAITSTRBUF_MAX ];
bool Init;
bool Compression;
bool ErrorCorrection;
bool HardwareFlowControl;
char ModemName [ MODEM_NAME_MAX ];
} SerialSettingsType;
/****************************************************************************
** These are the various commands sent during startup of a Serial game.
*/
typedef enum SerialCommandType : unsigned short {
SERIAL_CONNECT = 100, // Are you there? Hello? McFly?
SERIAL_GAME_OPTIONS = 101, // Hey, dudes, here's some new game options
SERIAL_SIGN_OFF = 102, // Bogus, dudes, my boss is coming; I'm outta here!
SERIAL_GO = 103, // OK, dudes, jump into the game loop!
SERIAL_MESSAGE = 104, // Here's a message
SERIAL_TIMING = 105, // timimg packet
SERIAL_SCORE_SCREEN = 106, // player at score screen
SERIAL_READY_TO_GO = 107, // Host is ready to start the game
SERIAL_LAST_COMMAND // last command
} SerialCommandType;
//
// how much time (ticks) to go by before sending another packet
// to simulate traffic.
//
#define PACKET_TIMING_TIMEOUT 40
/****************************************************************************
** These is the structure sent over the network Global Channel.
** Also used for the Null-Modem and Modem.
*/
typedef struct {
SerialCommandType Command; // One of the enum's defined above
char Name[MPLAYER_NAME_MAX]; // Player or Game Name
int Version; // game's version number
HousesType House; // player's House
unsigned char Color; // player's color or SIGNOFF ID
unsigned char Scenario; // Scenario #
unsigned int Credits; // player's credits
unsigned int IsBases : 1; // 1 = bases are allowed
unsigned int IsTiberium : 1; // 1 = tiberium is allowed
unsigned int IsGoodies : 1; // 1 = goodies are allowed
unsigned int IsGhosties : 1; // 1 = ghosts are allowed
unsigned char BuildLevel; // buildable level
unsigned char UnitCount; // max # units
int Seed; // random number seed
SpecialClass Special; // command-line options
unsigned int GameSpeed; // Game Speed
unsigned long ResponseTime; // packet response time
char Message[COMPAT_MESSAGE_LENGTH]; // inter-player message
unsigned char ID; // ID of sender of message
} SerialPacketType;
typedef enum ModemGameType : unsigned char {
MODEM_NULL_HOST = 0,
MODEM_NULL_JOIN,
MODEM_DIALER,
MODEM_ANSWERER,
INTERNET_HOST = MODEM_NULL_HOST,
INTERNET_JOIN = MODEM_NULL_JOIN
} ModemGameType;
/****************************************************************************
** This is the max number of events supported on one frame.
*/
#define MAX_EVENTS 256
/****************************************************************************
** These are the various commands sent over the network's Global Channel.
*/
typedef enum NetCommandType : unsigned char {
NET_QUERY_GAME, // Hey, what games are out there?
NET_ANSWER_GAME, // Yo, Here's my game's name!
NET_QUERY_PLAYER, // Hey, what players are in this game?
NET_ANSWER_PLAYER, // Yo, I'm in that game!
NET_QUERY_JOIN, // Hey guys, can I play too?
NET_CONFIRM_JOIN, // Well, OK, if you really want to.
NET_REJECT_JOIN, // No, you can't join; sorry, dude.
NET_GAME_OPTIONS, // Hey, dudes, here's some new game options
NET_SIGN_OFF, // Bogus, dudes, my boss is coming; I'm outta here!
NET_GO, // OK, dudes, jump into the game loop!
NET_MESSAGE, // Here's a message
NET_PING, // I'm pinging you to take a time measurement
} NetCommandType;
/****************************************************************************
** These is the structure sent over the network Global Channel.
*/
typedef struct {
NetCommandType Command; // One of the enum's defined above
char Name[MPLAYER_NAME_MAX]; // Player or Game Name
union {
struct {
int Version; // game's version number
unsigned int IsOpen : 1; // 1 = game is open for joining
} GameInfo;
struct {
HousesType House; // player's House
unsigned int Color; // player's color
unsigned long NameCRC; // CRC of player's game's name
} PlayerInfo;
struct {
unsigned char Scenario; // Scenario #
unsigned int Credits; // player's credits
unsigned int IsBases : 1; // 1 = bases are allowed
unsigned int IsTiberium : 1; // 1 = tiberium is allowed
unsigned int IsGoodies : 1; // 1 = goodies are allowed
unsigned int IsGhosties : 1; // 1 = ghosts are allowed
unsigned char BuildLevel; // buildable level
unsigned char UnitCount; // max # units
int Seed; // random number seed
SpecialClass Special; // command-line options
unsigned int GameSpeed; // Game Speed
} ScenarioInfo;
struct {
char Buf[COMPAT_MESSAGE_LENGTH]; // inter-user message
unsigned char ID; // ID of sender of message
unsigned long NameCRC; // CRC of sender's Game Name
} Message;
struct {
int OneWay; // one-way response time
} ResponseTime;
};
} GlobalPacketType;
/****************************************************************************
** This structure is for keeping score in multiplayer games.
*/
#define MAX_MULTI_NAMES 8 // max # names (rows) on the score screen
#define MAX_MULTI_GAMES 4 // max # games (columns) on the score screen
typedef struct {
char Name[MPLAYER_NAME_MAX];
int Wins;
int Kills[MAX_MULTI_GAMES];
int Color;
} MPlayerScoreType;
typedef enum {
KF_NUMBER = 0x08,
KF_UNCOMP = 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 {
SDLG_NONE,
SDLG_OPTIONS,
SDLG_SURRENDER,
SDLG_SPECIAL,
} SpecialDialogType;
typedef enum : unsigned char {
CC_GDI_COLOR = YELLOW,
CC_NOD_COLOR = RED,
CC_BLUE_GREEN = CYAN,
CC_BLUE_GREY = LTBLUE,
CC_ORANGE = PURPLE,
CC_GREEN = GREEN,
CC_TAN = BROWN,
CC_GREEN_SHADOW = 140,
CC_GREEN_BKGD = 141,
CC_GREEN_CORNERS = CC_GREEN_BKGD,
CC_LIGHT_GREEN = 159,
CC_GREEN_BOX = CC_LIGHT_GREEN,
CC_BRIGHT_GREEN = 167,
CC_UNDERLINE = CC_BRIGHT_GREEN,
CC_GREEN_BAR = CC_BRIGHT_GREEN,
} 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_SMALL_THUMB=18, // Small slider thumb.
OPTION_LARGE_THUMB=19, // Large slider thumb.
OPTION_PLAY=20, // Play track.
OPTION_STOP=22, // Stop track.
OPTION_UP_ARROW=24, // Slider up arrow.
OPTION_DOWN_ARROW=26, // Slider down arrow.
OPTION_BUTTON_GDI=28, // Huh?
OPTION_BUTTON_NOD=30, // Huh?
OPTION_COUNT
} OptionControlType;
/****************************************************************************
** Used to store firing data for a unit.
*/
typedef struct {
COORDINATE Center;
int Distance;
} FireDataType;
#define TOTAL_CRATE_TYPES 15
#define size_of(typ,id) sizeof(((typ*)0)->id)
/*
**
** Imports from Red Alert for AI. ST - 7/16/2019 11:44AM
**
**
**
*/
#ifdef USE_RA_AI
/**********************************************************************
** 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;
#endif //USE_RA_AI
#pragma warning (pop)
#endif