text: //
  // 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<FrameTimerClass> 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<FrameTimerClass> 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<BuildChoiceClass> 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