// // 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\house.h_v 2.21 16 Oct 1995 16:46:14 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 : HOUSE.H * * * * Programmer : Joe L. Bostic * * * * Start Date : May 21, 1994 * * * * Last Update : May 21, 1994 [JLB] * * * *---------------------------------------------------------------------------------------------* * Functions: * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ #ifndef HOUSE_H #define HOUSE_H #include "type.h" #include "region.h" #include "vector.h" #include "COORDA.h" #include "Credits.h" //extern "C" { //unsigned Cardinal_To_Fixed(unsigned base, unsigned cardinal); //} class TriggerClass; #ifdef USE_RA_AI class FootClass; // ST - 7/17/2019 11:54AM class FactoryClass; // ST - 7/17/2019 11:54AM #endif // USE_RA_AI /**************************************************************************** ** Player control structure. Each player (computer or human) has one of ** these structures associated. These are located in a global array. */ //#define REBUILD_MAX 5 // Maximum number of structures to rebuild. class HouseClass { public: /* ** Pointer to the HouseTypeClass that this house is "owned" by. ** All constant data for a house type is stored in that class. */ HouseTypeClass const * const Class; /* ** Override handicap control values. */ float FirepowerBias; float GroundspeedBias; float AirspeedBias; float ArmorBias; float ROFBias; float CostBias; float BuildSpeedBias; float RepairDelay; float BuildDelay; /* ** This is the house type that this house object should act like. This ** value controls production choices and radar cover plate imagery. */ HousesType ActLike; /* ** Is this player active? Usually that answer is true, but for civilians, it ** might possibly be false. */ unsigned IsActive:1; /* ** If this house is controlled by the player, then this flag will be true. The ** computer controls all other active houses. */ unsigned IsHuman:1; unsigned WasHuman:1; /* ** When the computer becomes alerted to the presence of the player's forces, it ** begins production and attack logic. This flag is set to true if the human ** player has been discovered by the computer. */ unsigned IsStarted:1; /* ** When alerted, the house will create teams of the special "auto" type and ** will generate appropriate units to fill those team types. */ unsigned IsAlerted:1; /* ** If the house has been discovered, then this flag will be set ** to true. However, the trigger even associated with discovery ** will only be executed during the next house AI process. */ unsigned IsDiscovered:1; /* ** If Tiberium storage is maxed out, then this flag will be set. At some point ** the player is told of this fact and then this flag is cleared. This allows the ** player to be told, but only occationally rather than continuously. */ unsigned IsMaxedOut:1; /* ** If this house is played by a human in a multiplayer game, this flag ** keeps track of whether this house has been defeated or not. */ unsigned IsDefeated:1; /* ** These flags are used in conjunction with the BorrowedTime timer. When ** that timer expires and one of these flags are set, then that event is ** applied to the house. This allows a dramatic pause between the event ** trigger and the result. */ unsigned IsToDie:1; unsigned IsToWin:1; unsigned IsToLose:1; /* ** This flag is set when a transport carrying a civilian has been ** successfully evacuated. It is presumed that a possible trigger ** event will be sprung by this event. */ unsigned IsCivEvacuated:1; /* ** If potentially something changed that might affect the sidebar list of ** buildable objects, then this flag indicates that at the first LEGAL opportunity, ** the sidebar will be recalculated. */ unsigned IsRecalcNeeded:1; /* ** If the map has been completely revealed to the player, then this flag ** will be set to true. By examining this flag, a second "reveal all map" ** crate won't be given to the player. */ unsigned IsVisionary:1; /* ** If a trigger has indicated that the airstrike option should appear, this flag ** will be set to true. It is up to the normal house AI processing to actually ** add the airstrike to the sidebar. */ unsigned IsAirstrikePending:1; /* ** This records the existance of the three nuke weapon pieces. */ unsigned NukePieces:3; /* ** This flag indicates that a free harvester is pending and will be ** created when the FreeHarvester timer expires. */ unsigned IsFreeHarvester:1; TCountDownTimerClass FreeHarvester; /* ** These super weapon control objects are used to control the recharge ** and availability of these special weapons to this house. */ SuperClass IonCannon; SuperClass AirStrike; SuperClass NukeStrike; /* ** This is a record of the last building that was built. For buildings that ** were built as a part of scenario creation, it will be the last one ** discovered. */ StructType JustBuilt; /* ** This records the number of triggers associated with this house that are ** blocking a win condition. A win will only occur if all the blocking ** triggers have been deleted. */ int Blockage; /* ** This timer controls the computer auto-attack logic. When this timer expires ** and the house has been alerted, then it will create a set of attack ** teams. */ TCountDownTimerClass AlertTime; /* ** This timer is used to handle the delay between some catastrophic ** event trigger and when it is actually carried out. */ TCountDownTimerClass BorrowedTime; /* ** This is the last working scan bits for buildings. If a building is ** active and owned by this house, it will have a bit set in this element ** that corresponds to the building type number. Since this value is ** accumulated over time, the "New" element contains the under-construction ** version. */ unsigned long BScan; unsigned long ActiveBScan; unsigned long NewBScan; unsigned long NewActiveBScan; #ifdef USE_RA_AI unsigned long OldBScan; #endif /* ** This is the last working scan bits for units. For every existing unit ** type owned by this house, a corresponding bit is set in this element. As ** the scan bits are being constructed, they are built into the "New" element ** and then duplicated into the regular element at the end of every logic cycle. */ unsigned long UScan; unsigned long ActiveUScan; unsigned long NewUScan; unsigned long NewActiveUScan; /* ** Infantry type existence bits. Similar to unit and building bits. */ unsigned long IScan; unsigned long ActiveIScan; unsigned long NewIScan; unsigned long NewActiveIScan; /* ** Aircraft type existence bits. Similar to unit and building buts. */ unsigned long AScan; unsigned long ActiveAScan; unsigned long NewAScan; unsigned long NewActiveAScan; /* ** Record of gains and losses for this house during the course of the ** scenario. */ unsigned CreditsSpent; unsigned HarvestedCredits; /* ** This is the running count of the number of units owned by this house. This ** value is used to keep track of ownership limits. */ unsigned CurUnits; unsigned CurBuildings; #ifdef USE_RA_AI unsigned CurInfantry; // Added from RA for AI. ST - 7/17/2019 12:03PM unsigned CurAircraft; // Added from RA for AI. ST - 7/17/2019 12:03PM #endif //USE_RA_AI /* ** This is the maximum number allowed to be built by this house. The ** value depends on the scenario being played. */ unsigned MaxUnit; unsigned MaxBuilding; #ifdef USE_RA_AI unsigned MaxInfantry; // Added from RA for AI. ST - 7/19/2019 4:31PM unsigned MaxAircraft; // Added from RA for AI. ST - 7/19/2019 4:31PM #endif //USE_RA_AI /* ** This is the running total of the number of credits this house has accumulated. */ long Tiberium; long Credits; long InitialCredits; long Capacity; /* ** Did this house lose via resignation? */ unsigned Resigned:1; /* ** Did this house lose because the player quit? */ unsigned IGaveUp:1; /* ** Stuff to keep track of the total number of units built by this house. */ UnitTrackerClass *AircraftTotals; UnitTrackerClass *InfantryTotals; UnitTrackerClass *UnitTotals; UnitTrackerClass *BuildingTotals; /* ** Total number of units destroyed by this house */ UnitTrackerClass *DestroyedAircraft; UnitTrackerClass *DestroyedInfantry; UnitTrackerClass *DestroyedUnits; UnitTrackerClass *DestroyedBuildings; /* ** Total number of enemy buildings captured by this house */ UnitTrackerClass *CapturedBuildings; /* ** Total number of crates found by this house */ UnitTrackerClass *TotalCrates; /* ** Records the number of infantry and vehicle factories active. This value is ** used to regulate the speed of production. */ int AircraftFactories; int InfantryFactories; int UnitFactories; int BuildingFactories; int SpecialFactories; /* ** This is the accumulation of the total power and drain factors. From these ** values a ratio can be derived. This ratio is used to control the rate ** of building decay. */ int Power; // Current power output. int Drain; // Power consumption. /* ** For generic (unspecified) reinforcements, they arrive by a common method. This ** specifies which method is to be used. */ SourceType Edge; /* ** For human controlled houses, only one type of unit can be produced ** at any one instant. These factory objects control this production. */ int AircraftFactory; int InfantryFactory; int UnitFactory; int BuildingFactory; int SpecialFactory; /* ** For human controlled houses, the current state of the radar map */ RadarEnum Radar; /* ** This target value specifies where the flag is located. It might be a cell ** or it might be an object. */ TARGET FlagLocation; /* ** This is the flag-home-cell for this house. This is where we must bring ** another house's flag back to, to defeat that house. */ CELL FlagHome; /* ** For multiplayer games, each house instance has a remap table; the table ** in the HousesTypeClass isn't used. This variable is set to the remap ** table for the color the player wants to play. */ unsigned char const * RemapTable; PlayerColorType RemapColor; char Name[MPLAYER_NAME_MAX]; /* ** For multiplayer games, each house needs to keep track of how many ** objects of each other house they've killed. */ unsigned UnitsKilled[HOUSE_COUNT]; unsigned UnitsLost; unsigned BuildingsKilled[HOUSE_COUNT]; unsigned BuildingsLost; /* ** For multiplayer games, this keeps track of the last house to destroy ** one of my units. */ HousesType WhoLastHurtMe; /* ** Start location (waypoint index) passed in from GlyphX */ int StartLocationOverride; /*--------------------------------------------------------------------- ** Constructors, Destructors, and overloaded operators. */ static void * operator new(size_t size); static void operator delete(void *ptr); HouseClass(void) : Class(0) {}; HouseClass(HousesType house); ~HouseClass(void); operator HousesType(void) const; /*--------------------------------------------------------------------- ** Member function prototypes. */ ProdFailType Begin_Production(RTTIType type, int id); ProdFailType Suspend_Production(RTTIType type); ProdFailType Abandon_Production(RTTIType type); bool Place_Object(RTTIType type, CELL cell); bool Manual_Place(BuildingClass * builder, BuildingClass * object); void Special_Weapon_AI(SpecialWeaponType id); bool Place_Special_Blast(SpecialWeaponType id, CELL cell); bool Flag_Attach(CELL cell, bool set_home = false); bool Flag_Attach(UnitClass * object, bool set_home = false); bool Flag_Remove(TARGET target, bool set_home = false); void Init_Data(PlayerColorType color, HousesType house, int credits); void Sell_Wall(CELL cell); bool Flag_To_Die(void); bool Flag_To_Win(void); bool Flag_To_Lose(void); void Make_Ally(HousesType house); void Make_Ally(ObjectClass * object) {if (object) Make_Ally(object->Owner());}; void Make_Enemy(HousesType house); void Make_Enemy(ObjectClass * object) {if (object) Make_Enemy(object->Owner());}; bool Is_Ally(HousesType house) const; bool Is_Ally(HouseClass const * house) const; bool Is_Ally(ObjectClass const * object) const; unsigned int Get_Allies(void) const {return Allies;} #ifdef CHEAT_KEYS void Debug_Dump(MonoClass *mono) const; #endif void AI(void); bool Can_Build(StructType structure, HousesType house) const; bool Can_Build(InfantryType infantry, HousesType house) const; bool Can_Build(UnitType unit, HousesType) const; bool Can_Build(AircraftType aircraft, HousesType house) const; bool Can_Build(TechnoTypeClass const * type, HousesType house) const; unsigned char const * Remap_Table(bool blushing=false, bool unit=false) const; TechnoTypeClass const * Suggest_New_Object(RTTIType objectype) const; bool Does_Enemy_Building_Exist(StructType) const; void Harvested(unsigned tiberium); long Available_Money(void) const; void Spend_Money(unsigned money); void Refund_Money(unsigned money); void Attacked(BuildingClass* source); #ifndef USE_RA_AI void Adjust_Power(int adjust) {Power += adjust;}; // Replaced by function from RA. ST - 7/17/2019 11:51AM void Adjust_Drain(int adjust) {Drain += adjust;}; // Replaced by function from RA. ST - 7/17/2019 11:51AM #endif int Adjust_Capacity(int adjust, bool inanger=false); int Power_Fraction(void) const; int Tiberium_Fraction(void) {return (!Tiberium) ? 0 : Cardinal_To_Fixed(Capacity, Tiberium);}; void Begin_Production(void) {IsStarted = true;}; TeamTypeClass const * Suggested_New_Team(bool alertcheck = false); void Adjust_Threat(int region, int threat); static void Init(void); static void One_Time(void); static HouseClass * As_Pointer(HousesType house); /* ** File I/O. */ static void Read_INI(char *buffer); static void Write_INI(char *buffer); static void Read_Flag_INI(char *buffer); static void Write_Flag_INI(char *buffer); bool Load(FileClass & file); bool Save(FileClass & file); void Code_Pointers(void); void Decode_Pointers(void); /* ** Dee-buggin' support. */ int Validate(void) const; /* ** Special house actions. */ // void Init_Ion_Cannon(bool first_time, bool one_time_effect = false); // void Init_Air_Strike(bool first_time, bool one_time_effect = false); // void Init_Nuke_Bomb(bool first_time, bool one_time_effect = false); // void Remove_Ion_Cannon(void); // void Remove_Air_Strike(void); // void Remove_Nuke_Bomb(void); void Detach(TARGET target, bool all); void Add_Nuke_Piece(int piece=-1); // void Make_Air_Strike_Available(bool present, bool one_time_effect = false); bool Has_Nuke_Device(void); /* ** New default win mode to avoid griefing. ST - 1/31/2020 3:33PM */ void Check_Pertinent_Structures(void); void Init_Unit_Trackers(void); void Free_Unit_Trackers(void); // MBL 09.08.2020 Mod support stub void Handle_Mod_Game_Command(CELL cell, int mod_command_index); // mod_command_index = 0-3 #ifdef USE_RA_AI /* ** AI Functions imported from RA */ //TechnoTypeClass const * Suggest_New_Object(RTTIType objectype, bool kennel=false) const; BuildingTypeClass const * Suggest_New_Building(void) const; void Recalc_Center(void); //void Harvested(unsigned tiberium); void Stole(unsigned worth); //long Available_Money(void) const; //void Spend_Money(unsigned money); //void Refund_Money(unsigned money); //void Attacked(void); void Adjust_Power(int adjust); void Adjust_Drain(int adjust); //int Adjust_Capacity(int adjust, bool inanger=false); //fixed Power_Fraction(void) const; //fixed Tiberium_Fraction(void) const; //void Begin_Production(void) {IsStarted = true;}; //TeamTypeClass const * Suggested_New_Team(bool alertcheck = false); //void Adjust_Threat(int region, int threat); void Tracking_Remove(TechnoClass const * techno); void Tracking_Add(TechnoClass const * techno); void Active_Remove(TechnoClass const * techno); void Active_Add(TechnoClass const * techno); UrgencyType Check_Attack(void) const; UrgencyType Check_Build_Power(void) const; UrgencyType Check_Build_Defense(void) const; UrgencyType Check_Build_Offense(void) const; UrgencyType Check_Build_Income(void) const; UrgencyType Check_Fire_Sale(void) const; UrgencyType Check_Build_Engineer(void) const; UrgencyType Check_Raise_Money(void) const; UrgencyType Check_Raise_Power(void) const; UrgencyType Check_Lower_Power(void) const; bool AI_Attack(UrgencyType urgency); bool AI_Build_Power(UrgencyType urgency) const; bool AI_Build_Defense(UrgencyType urgency) const; bool AI_Build_Offense(UrgencyType urgency) const; bool AI_Build_Income(UrgencyType urgency) const; bool AI_Fire_Sale(UrgencyType urgency); bool AI_Build_Engineer(UrgencyType urgency) const; bool AI_Raise_Money(UrgencyType urgency) const; bool AI_Raise_Power(UrgencyType urgency) const; bool AI_Lower_Power(UrgencyType urgency) const; bool Can_Make_Money(void) const { return(Available_Money() > 300 || (BScan & STRUCTF_REFINERY)); }; int Expert_AI(void); COORDINATE Find_Build_Location(BuildingClass * building) const; BuildingClass * Find_Building(StructType type, ZoneType zone=ZONE_NONE) const; int AI_Building(void); int AI_Unit(void); int AI_Vessel(void); int AI_Infantry(void); int AI_Aircraft(void); void Production_Begun(TechnoClass const * rtti); int * Factory_Counter(RTTIType rtti); int Factory_Count(RTTIType rtti) const; CELL Where_To_Go(FootClass const * object) const; CELL Zone_Cell(ZoneType zone) const; ZoneType Which_Zone(COORDINATE coord) const; ZoneType Which_Zone(ObjectClass const * object) const; ZoneType Which_Zone(CELL cell) const; DiffType Assign_Handicap(DiffType handicap); TARGET Find_Juicy_Target(COORDINATE coord) const; int Get_Quantity(AircraftType aircraft); int Get_Quantity(StructType building); FactoryClass * Fetch_Factory(RTTIType rtti) const; void Set_Factory(RTTIType rtti, FactoryClass * factory); bool Fire_Sale(void); bool Is_Hack_Prevented(RTTIType rtti, int value) const; bool Is_No_YakMig(void) const; CELL Random_Cell_In_Zone(ZoneType zone) const; static void Computer_Paranoid(void); bool Is_Allowed_To_Ally(HousesType house) const; void Do_All_To_Hunt(void) const; void Super_Weapon_Handler(void); CELL Find_Cell_In_Zone(TechnoClass const * techno, ZoneType zone) const; // Added so the ally flags could be sent to client machines - 09 / 12 / 2019 JAS unsigned Get_Ally_Flags(); static void Recalc_Attributes(void); #endif //USE_RA_AI /* ** This vector holds the recorded status of the map regions. It is through ** this region information that team paths are calculated. */ RegionClass Regions[MAP_TOTAL_REGIONS]; #ifdef OBSOLETE /* ** This count down timer class handles decrements and then changes ** the ion cannon state. If the Ion cannon was out of range it is ** now in range. If the Ion cannon was in range it will toggle out ** of range. */ TCountDownTimerClass IonControl; int IonOldStage; TCountDownTimerClass AirControl; int AirOldStage; TCountDownTimerClass NukeControl; int NukeOldStage; #endif /* ** This timer is for multiplayer mode; for a computer-controlled house, ** it determines how long until this player "blitzes" the hapless humans. */ TCountDownTimerClass BlitzTime; /* ** This count down timer class decrements and then changes ** the Atomic Bomb state. */ CELL NukeDest; /* ** Per-house credits class to track the visible credits state for each house. Redundant in the original game, but needed ** to preserve the exact credits count behavior in the GlyphX client. ST - 10/16/2019 2:31PM */ CreditClass VisibleCredits; bool DebugUnlockBuildables; /* ** This routine completely removes this house & all its objects from the game. */ void Clobber_All(void); /* ** This routine blows up everything in this house. Fun! */ void Blowup_All(void); /* ** This routine gets called in multiplayer games when every unit, building, ** and infantry for a house is destroyed. */ void MPlayer_Defeated(void); /* ** Screen shake timer. */ TCountDownTimerClass ScreenShakeTime; private: void Silo_Redraw_Check(long oldtib, long oldcap); /* ** This is a bit field record of all the other houses that are allies with ** this house. It is presumed that any house that isn't an ally, is therefore ** an enemy. A house is always considered allied with itself. */ unsigned Allies; /* ** This is the standard delay time between announcements concerning the ** state of the base or other intermittent house related events. */ enum SpeakDelayEnum { SPEAK_DELAY=TICKS_PER_MINUTE*2, TEAM_DELAY=TICKS_PER_MINUTE/10, DAMAGE_DELAY=TICKS_PER_MINUTE }; /* ** General low-power related damaged is doled out whenever this timer ** expires. */ TCountDownTimerClass DamageTime; /* ** Team creation is done whenever this timer expires. */ TCountDownTimerClass TeamTime; /* ** This controls the rate that the trigger time logic is processed. */ TCountDownTimerClass TriggerTime; /* ** At various times, the computer may announce the player's condition. The following ** variables are used as countdown timers so that these announcements are paced ** far enough appart to reduce annoyance. */ TCountDownTimerClass SpeakAttackDelay; TCountDownTimerClass SpeakPowerDelay; TCountDownTimerClass SpeakMoneyDelay; TCountDownTimerClass SpeakMaxedDelay; #ifdef USE_RA_AI /*************************************************************************************** ** ** AI data imported from RA. ST - 7/17/2019 11:35AM ** ** */ public: /* ** This records information about the location and size of ** the base. */ COORDINATE Center; // Center of the base. int Radius; // Average building distance from center (leptons). struct { int AirDefense; int ArmorDefense; int InfantryDefense; } ZoneInfo[ZONE_COUNT]; /* ** This records information about the last time a building of this ** side was attacked. This information is used to determine proper ** response. */ int LATime; // Time of attack. RTTIType LAType; // Type of attacker. ZoneType LAZone; // Last zone that was attacked. HousesType LAEnemy; // Owner of attacker. /* ** This target value is the building that must be captured as soon as possible. ** Typically, this will be one of the buildings of this house that has been ** captured and needs to be recaptured. */ TARGET ToCapture; /* ** This value shows who is spying on this house's radar facilities. ** This is used for the other side to be able to update their radar ** map based on the cells that this house's units reveal. */ int RadarSpied; /* ** Running score, based on units destroyed and units lost. */ int PointTotal; /* ** This is the targeting directions for when this house gets a ** special weapon. */ //QuarryType PreferredTarget; private: /* ** Tracks number of each building type owned by this house. Even if the ** building is in construction, it will be reflected in this total. */ int BQuantity[STRUCT_COUNT]; int UQuantity[UNIT_COUNT]; int IQuantity[INFANTRY_COUNT]; int AQuantity[AIRCRAFT_COUNT]; /* ** This timer keeps track of when an all out attack should be performed. ** When this timer expires, send most of this house's units in an ** attack. */ /////CDTimerClass Attack; TCountDownTimerClass Attack; public: /* ** This records the overriding enemy that the computer will try to ** destroy. Typically, this is the last house to attack, but can be ** influenced by nearness. */ HousesType Enemy; /* ** The house expert system is regulated by this timer. Each computer controlled ** house will process the Expert System AI at intermittent intervals. Not only will ** this distribute the overhead more evenly, but will add variety to play. */ /////CDTimerClass AITimer; TCountDownTimerClass AITimer; /* ** For the moebius effect, this is a pointer to the unit that we ** selected to teleport. Only one teleporter should be active per house. */ //TARGET UnitToTeleport; /* ** This elaborates the suggested objects to construct. When the specified object ** is constructed, then this corresponding value will be reset to nill state. The ** expert system decides what should be produced, and then records the ** recommendation in these variables. */ StructType BuildStructure; UnitType BuildUnit; InfantryType BuildInfantry; AircraftType BuildAircraft; //VesselType BuildVessel; /* ** This records the current state of the base. This state is used to control ** what action the base will perform and directly affects production and ** unit disposition. The state will change according to time and combat ** events. */ StateType State; /* ** If automatic base building is on, then this flag will be set to true. */ unsigned IsBaseBuilding:1; /* ** This flag is set to true when the house has determined that ** there is insufficient Tiberium to keep the harvesters busy. ** In such a case, the further refinery/harvester production ** should cease. This is one of the first signs that the endgame ** has begun. */ unsigned IsTiberiumShort:1; /* ** If this computer controlled house has reason to be mad at humans, ** then this flag will be true. Such a condition prevents alliances with ** a human and encourages the computers players to ally amongst themselves. */ unsigned IsParanoid:1; /* ** This value indicates the degree of smartness to assign to this house. ** A value is zero is presumed for human controlled houses. */ int IQ; /* ** This is the handicap (difficulty level) assigned to this house. */ DiffType Difficulty; /* ** This structure is used to record a build request as determined by ** the house AI processing. Higher priority build requests take precidence. */ struct BuildChoiceClass { static void * operator new(size_t, void * ptr) {return(ptr);}; UrgencyType Urgency; // The urgency of the build request. StructType Structure; // The type of building to produce. BuildChoiceClass(UrgencyType u, StructType s) : Urgency(u), Structure(s) {}; int Save(FileClass &) const {return(true);}; int Load(FileClass &) {return(true);}; void Code_Pointers(void) {}; void Decode_Pointers(void) {}; }; static TFixedIHeapClass BuildChoice; #endif // USE_RA_AI /* ** Some additional padding in case we need to add data to the class and maintain backwards compatibility for save/load */ unsigned char SaveLoadPadding[256]; }; #endif