RedAlert/CODE/HOUSE.CPP

/*
**	Command & Conquer Red Alert(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program 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.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/* $Header: /counterstrike/HOUSE.CPP 4     3/13/97 7:11p Steve_tall $ */
/***********************************************************************************************
 ***              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.CPP                                                    *
 *                                                                                             *
 *                   Programmer : Joe L. Bostic                                                *
 *                                                                                             *
 *                   Start Date : May 21, 1994                                                 *
 *                                                                                             *
 *                  Last Update : November 4, 1996 [JLB]                                       *
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 *   HouseClass::AI -- Process house logic.                                                    *
 *   HouseClass::AI_Aircraft -- Determines what aircraft to build next.                        *
 *   HouseClass::AI_Attack -- Handles offensive attack logic.                                  *
 *   HouseClass::AI_Base_Defense -- Handles maintaining a strong base defense.                 *
 *   HouseClass::AI_Building -- Determines what building to build.                             *
 *   HouseClass::AI_Fire_Sale -- Check for and perform a fire sale.                            *
 *   HouseClass::AI_Infantry -- Determines the infantry unit to build.                         *
 *   HouseClass::AI_Money_Check -- Handles money production logic.                             *
 *   HouseClass::AI_Power_Check -- Handle the power situation.                                 *
 *   HouseClass::AI_Unit -- Determines what unit to build next.                                *
 *   HouseClass::Abandon_Production -- Abandons production of item type specified.             *
 *   HouseClass::Active_Add -- Add an object to active duty for this house.                    *
 *   HouseClass::Active_Remove -- Remove this object from active duty for this house.          *
 *   HouseClass::Adjust_Capacity -- Adjusts the house Tiberium storage capacity.               *
 *   HouseClass::Adjust_Drain -- Adjust the power drain value of the house.                    *
 *   HouseClass::Adjust_Power -- Adjust the power value of the house.                          *
 *   HouseClass::Adjust_Threat -- Adjust threat for the region specified.                      *
 *   HouseClass::As_Pointer -- Converts a house number into a house object pointer.            *
 *   HouseClass::Assign_Handicap -- Assigns the specified handicap rating to the house.        *
 *   HouseClass::Attacked -- Lets player know if base is under attack.                         *
 *   HouseClass::Available_Money -- Fetches the total credit worth of the house.               *
 *   HouseClass::Begin_Production -- Starts production of the specified object type.           *
 *   HouseClass::Blowup_All -- blows up everything                                             *
 *   HouseClass::Can_Build -- General purpose build legality checker.                          *
 *   HouseClass::Clobber_All -- removes all objects for this house                             *
 *   HouseClass::Computer_Paranoid -- Cause the computer players to becom paranoid.            *
 *   HouseClass::Debug_Dump -- Dumps the house status data to the mono screen.                 *
 *   HouseClass::Detach -- Removes specified object from house tracking systems.               *
 *   HouseClass::Do_All_To_Hunt -- Send all units to hunt.                                     *
 *   HouseClass::Does_Enemy_Building_Exist -- Checks for enemy building of specified type.     *
 *   HouseClass::Expert_AI -- Handles expert AI processing.                                    *
 *   HouseClass::Factory_Count -- Fetches the number of factories for specified type.          *
 *   HouseClass::Factory_Counter -- Fetches a pointer to the factory counter value.            *
 *   HouseClass::Fetch_Factory -- Finds the factory associated with the object type specified. *
 *   HouseClass::Find_Build_Location -- Finds a suitable building location.                    *
 *   HouseClass::Find_Building -- Finds a building of specified type.                          *
 *   HouseClass::Find_Cell_In_Zone -- Finds a legal placement cell within the zone.            *
 *   HouseClass::Find_Juicy_Target -- Finds a suitable field target.                           *
 *   HouseClass::Fire_Sale -- Cause all buildings to be sold.                                  *
 *   HouseClass::Flag_Attach -- Attach flag to specified cell (or thereabouts).                *
 *   HouseClass::Flag_Attach -- Attaches the house flag the specified unit.                    *
 *   HouseClass::Flag_Remove -- Removes the flag from the specified target.                    *
 *   HouseClass::Flag_To_Die -- Flags the house to blow up soon.                               *
 *   HouseClass::Flag_To_Lose -- Flags the house to die soon.                                  *
 *   HouseClass::Flag_To_Win -- Flags the house to win soon.                                   *
 *   HouseClass::Get_Quantity -- Fetches the total number of aircraft of the specified type.   *
 *   HouseClass::Get_Quantity -- Gets the quantity of the building type specified.             *
 *   HouseClass::Harvested -- Adds Tiberium to the harvest storage.                            *
 *   HouseClass::HouseClass -- Constructor for a house object.                                 *
 *   HouseClass::Init -- init's in preparation for new scenario                                *
 *   HouseClass::Init_Data -- Initializes the multiplayer color data.                          *
 *   HouseClass::Is_Allowed_To_Ally -- Determines if this house is allied to make allies.      *
 *   HouseClass::Is_Ally -- Checks to see if the object is an ally.                            *
 *   HouseClass::Is_Ally -- Determines if the specified house is an ally.                      *
 *   HouseClass::Is_Hack_Prevented -- Is production of the specified type and id prohibted?    *
 *   HouseClass::Is_No_YakMig -- Determines if no more yaks or migs should be allowed.         *
 *   HouseClass::MPlayer_Defeated -- multiplayer; house is defeated                            *
 *   HouseClass::Make_Ally -- Make the specified house an ally.                                *
 *   HouseClass::Make_Enemy -- Make an enemy of the house specified.                           *
 *   HouseClass::Manual_Place -- Inform display system of building placement mode.             *
 *   HouseClass::One_Time -- Handles one time initialization of the house array.               *
 *   HouseClass::Place_Object -- Places the object (building) at location specified.           *
 *   HouseClass::Place_Special_Blast -- Place a special blast effect at location specified.    *
 *   HouseClass::Power_Fraction -- Fetches the current power output rating.                    *
 *   HouseClass::Production_Begun -- Records that production has begun.                        *
 *   HouseClass::Read_INI -- Reads house specific data from INI.                               *
 *   HouseClass::Recalc_Attributes -- Recalcs all houses existence bits.                       *
 *   HouseClass::Recalc_Center -- Recalculates the center point of the base.                   *
 *   HouseClass::Refund_Money -- Refunds money to back to the house.                           *
 *   HouseClass::Remap_Table -- Fetches the remap table for this house object.                 *
 *   HouseClass::Sell_Wall -- Tries to sell the wall at the specified location.                *
 *   HouseClass::Set_Factory -- Assign specified factory to house tracking.                    *
 *   HouseClass::Silo_Redraw_Check -- Flags silos to be redrawn if necessary.                  *
 *   HouseClass::Special_Weapon_AI -- Fires special weapon.                                    *
 *   HouseClass::Spend_Money -- Removes money from the house.                                  *
 *   HouseClass::Suggest_New_Building -- Examines the situation and suggests a building.       *
 *   HouseClass::Suggest_New_Object -- Determine what would the next buildable object be.      *
 *   HouseClass::Suggested_New_Team -- Determine what team should be created.                  *
 *   HouseClass::Super_Weapon_Handler -- Handles the super weapon charge and discharge logic.  *
 *   HouseClass::Suspend_Production -- Temporarily puts production on hold.                    *
 *   HouseClass::Tally_Score -- Fills in the score system for this round                       *
 *   HouseClass::Tiberium_Fraction -- Calculates the tiberium fraction of capacity.            *
 *   HouseClass::Tracking_Add -- Informs house of new inventory item.                          *
 *   HouseClass::Tracking_Remove -- Remove object from house tracking system.                  *
 *   HouseClass::Where_To_Go -- Determines where the object should go and wait.                *
 *   HouseClass::Which_Zone -- Determines what zone a coordinate lies in.                      *
 *   HouseClass::Which_Zone -- Determines which base zone the specified cell lies in.          *
 *   HouseClass::Which_Zone -- Determines which base zone the specified object lies in.        *
 *   HouseClass::Write_INI -- Writes the house data to the INI database.                       *
 *   HouseClass::Zone_Cell -- Finds the cell closest to the center of the zone.                *
 *   HouseClass::delete -- Deallocator function for a house object.                            *
 *   HouseClass::new -- Allocator for a house class.                                           *
 *   HouseClass::operator HousesType -- Conversion to HousesType operator.                     *
 *   HouseClass::~HouseClass -- Default destructor for a house object.                         *
 *   HouseStaticClass::HouseStaticClass -- Default constructor for house static class.         *
 *   HouseClass::AI_Raise_Power -- Try to raise power levels by selling off buildings.         *
 *   HouseClass::AI_Raise_Money -- Raise emergency cash by selling buildings.                  *
 *   HouseClass::Random_Cell_In_Zone -- Find a (technically) legal cell in the zone specified. *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include	"function.h"
#include	"vortex.h"

//#include "WolDebug.h"

TFixedIHeapClass<HouseClass::BuildChoiceClass> HouseClass::BuildChoice;

int TFixedIHeapClass<HouseClass::BuildChoiceClass>::Save(Pipe &) const
{
	return(true);
}

int TFixedIHeapClass<HouseClass::BuildChoiceClass>::Load(Straw &)
{
	return(0);
}

void TFixedIHeapClass<HouseClass::BuildChoiceClass>::Code_Pointers(void)
{
}

void TFixedIHeapClass<HouseClass::BuildChoiceClass>::Decode_Pointers(void)
{
}

extern bool RedrawOptionsMenu;

/***********************************************************************************************
 * HouseClass::operator HousesType -- Conversion to HousesType operator.                       *
 *                                                                                             *
 *    This operator will automatically convert from a houses class object into the HousesType  *
 *    enumerated value.                                                                        *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the object's HousesType value.                                        *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/23/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
HouseClass::operator HousesType(void) const
{
	assert(Houses.ID(this) == ID);

	return(Class->House);
}


/***********************************************************************************************
 * HouseClass::Tiberium_Fraction -- Calculates the tiberium fraction of capacity.              *
 *                                                                                             *
 *    This will calculate the current tiberium (gold) load as a ratio of the maximum storage   *
 *    capacity.                                                                                *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns the current tiberium storage situation as a ratio of load over capacity.   *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/31/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
fixed HouseClass::Tiberium_Fraction(void) const
{
	if (Tiberium == 0) {
		return(0);
	}
	return(fixed(Tiberium, Capacity));
}


/***********************************************************************************************
 * HouseClass::As_Pointer -- Converts a house number into a house object pointer.              *
 *                                                                                             *
 *    Use this routine to convert a house number into the house pointer that it represents.    *
 *    A simple index into the Houses template array is not sufficient, since the array order   *
 *    is arbitrary. An actual scan through the house object is required in order to find the   *
 *    house object desired.                                                                    *
 *                                                                                             *
 * INPUT:   house -- The house type number to look up.                                         *
 *                                                                                             *
 * OUTPUT:  Returns with a pointer to the house object that the house number represents.       *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/23/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
HouseClass * HouseClass::As_Pointer(HousesType house)
{
	if (house != HOUSE_NONE) {
		for (int index = 0; index < Houses.Count(); index++) {
			if (Houses.Ptr(index)->Class->House == house) {
				return(Houses.Ptr(index));
			}
		}
	}
	return(0);
}


/***********************************************************************************************
 * HouseClass::One_Time -- Handles one time initialization of the house array.                 *
 *                                                                                             *
 *    This basically calls the constructor for each of the houses in the game. All other       *
 *    data specific to the house is initialized when the scenario is loaded.                   *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   Only call this ONCE at the beginning of the game.                               *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/09/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::One_Time(void)
{
	BuildChoice.Set_Heap(STRUCT_COUNT);
}


/***********************************************************************************************
 * HouseClass::Assign_Handicap -- Assigns the specified handicap rating to the house.          *
 *                                                                                             *
 *    The handicap rating will affect combat, movement, and production for the house. It can   *
 *    either make it more or less difficult for the house (controlled by the handicap value).  *
 *                                                                                             *
 * INPUT:   handicap -- The handicap value to assign to this house. The default value for      *
 *                      a house is DIFF_NORMAL.                                                *
 *                                                                                             *
 * OUTPUT:  Returns with the old handicap value.                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/09/1996 JLB : Created.                                                                 *
 *   10/22/1996 JLB : Uses act like value for multiplay only.                                  *
 *=============================================================================================*/
DiffType HouseClass::Assign_Handicap(DiffType handicap)
{
	DiffType old = Difficulty;
	Difficulty = handicap;

	if (Session.Type != GAME_NORMAL) {
		HouseTypeClass const * hptr = &HouseTypeClass::As_Reference(ActLike);
		FirepowerBias = hptr->FirepowerBias * Rule.Diff[handicap].FirepowerBias;
		GroundspeedBias = hptr->GroundspeedBias * Rule.Diff[handicap].GroundspeedBias * Rule.GameSpeedBias;
		AirspeedBias = hptr->AirspeedBias * Rule.Diff[handicap].AirspeedBias * Rule.GameSpeedBias;
		ArmorBias = hptr->ArmorBias * Rule.Diff[handicap].ArmorBias;
		ROFBias = hptr->ROFBias * Rule.Diff[handicap].ROFBias;
		CostBias = hptr->CostBias * Rule.Diff[handicap].CostBias;
		RepairDelay = Rule.Diff[handicap].RepairDelay;
		BuildDelay = Rule.Diff[handicap].BuildDelay;
		BuildSpeedBias = hptr->BuildSpeedBias * Rule.Diff[handicap].BuildSpeedBias * Rule.GameSpeedBias;
	} else {
		FirepowerBias = Rule.Diff[handicap].FirepowerBias;
		GroundspeedBias = Rule.Diff[handicap].GroundspeedBias * Rule.GameSpeedBias;
		AirspeedBias = Rule.Diff[handicap].AirspeedBias * Rule.GameSpeedBias;
		ArmorBias = Rule.Diff[handicap].ArmorBias;
		ROFBias = Rule.Diff[handicap].ROFBias;
		CostBias = Rule.Diff[handicap].CostBias;
		RepairDelay = Rule.Diff[handicap].RepairDelay;
		BuildDelay = Rule.Diff[handicap].BuildDelay;
		BuildSpeedBias = Rule.Diff[handicap].BuildSpeedBias * Rule.GameSpeedBias;
	}

	return(old);
}



#ifdef CHEAT_KEYS

void HouseClass::Print_Zone_Stats(int x, int y, ZoneType zone, MonoClass * mono) const
{
	mono->Set_Cursor(x, y);
	mono->Printf("A:%-5d I:%-5d V:%-5d", ZoneInfo[zone].AirDefense, ZoneInfo[zone].InfantryDefense, ZoneInfo[zone].ArmorDefense);
}


/***********************************************************************************************
 * HouseClass::Debug_Dump -- Dumps the house status data to the mono screen.                   *
 *                                                                                             *
 *    This utility function will output the current status of the house class to the mono      *
 *    screen. Through this information bugs may be fixed or detected.                          *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/31/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Debug_Dump(MonoClass * mono) const
{
	mono->Set_Cursor(0, 0);
	mono->Print(Text_String(TXT_DEBUG_HOUSE));

	mono->Set_Cursor(1, 1);mono->Printf("[%d]%14.14s", Class->House, Name());
	mono->Set_Cursor(20, 1);mono->Printf("[%d]%13.13s", ActLike, HouseTypeClass::As_Reference(ActLike).Name());
	mono->Set_Cursor(39, 1);mono->Printf("%2d", Control.TechLevel);
	mono->Set_Cursor(45, 1);mono->Printf("%2d", Difficulty);
	mono->Set_Cursor(52, 1);mono->Printf("%2d", State);
	mono->Set_Cursor(58, 1);mono->Printf("%2d", Blockage);
	mono->Set_Cursor(65, 1);mono->Printf("%2d", IQ);
	mono->Set_Cursor(72, 1);mono->Printf("%5d", (long)RepairTimer);

	mono->Set_Cursor(1, 3);mono->Printf("%08X", AScan);
	mono->Set_Cursor(10, 3);mono->Printf("%8.8s", (BuildAircraft == AIRCRAFT_NONE) ? " " : AircraftTypeClass::As_Reference(BuildAircraft).Graphic_Name());
	mono->Set_Cursor(21, 3);mono->Printf("%3d", CurAircraft);
	mono->Set_Cursor(27, 3);mono->Printf("%8d", Credits);
	mono->Set_Cursor(37, 3);mono->Printf("%5d", Power);
	mono->Set_Cursor(45, 3);mono->Printf("%04X", RadarSpied);
	mono->Set_Cursor(52, 3);mono->Printf("%5d", PointTotal);
	mono->Set_Cursor(62, 3);mono->Printf("%5d", (long)TeamTime);
	mono->Set_Cursor(71, 3);mono->Printf("%5d", (long)AlertTime);

	mono->Set_Cursor(1, 5);mono->Printf("%08X", BScan);
	mono->Set_Cursor(10, 5);mono->Printf("%8.8s", (BuildStructure == STRUCT_NONE) ? " " : BuildingTypeClass::As_Reference(BuildStructure).Graphic_Name());
	mono->Set_Cursor(21, 5);mono->Printf("%3d", CurBuildings);
	mono->Set_Cursor(27, 5);mono->Printf("%8d", Tiberium);
	mono->Set_Cursor(37, 5);mono->Printf("%5d", Drain);
	mono->Set_Cursor(44, 5);mono->Printf("%16.16s", QuarryName[PreferredTarget]);
	mono->Set_Cursor(62, 5);mono->Printf("%5d", (long)TriggerTime);
	mono->Set_Cursor(71, 5);mono->Printf("%5d", (long)BorrowedTime);

	mono->Set_Cursor(1, 7);mono->Printf("%08X", UScan);
	mono->Set_Cursor(10, 7);mono->Printf("%8.8s", (BuildUnit == UNIT_NONE) ? " " : UnitTypeClass::As_Reference(BuildUnit).Graphic_Name());
	mono->Set_Cursor(21, 7);mono->Printf("%3d", CurUnits);
	mono->Set_Cursor(27, 7);mono->Printf("%8d", Control.InitialCredits);
	mono->Set_Cursor(38, 7);mono->Printf("%5d", UnitsLost);
	mono->Set_Cursor(44, 7);mono->Printf("%08X", Allies);
	mono->Set_Cursor(71, 7);mono->Printf("%5d", (long)Attack);

	mono->Set_Cursor(1, 9);mono->Printf("%08X", IScan);
	mono->Set_Cursor(10, 9);mono->Printf("%8.8s", (BuildInfantry == INFANTRY_NONE) ? " " : InfantryTypeClass::As_Reference(BuildInfantry).Graphic_Name());
	mono->Set_Cursor(21, 9);mono->Printf("%3d", CurInfantry);
	mono->Set_Cursor(27, 9);mono->Printf("%8d", Capacity);
	mono->Set_Cursor(38, 9);mono->Printf("%5d", BuildingsLost);
	mono->Set_Cursor(45, 9);mono->Printf("%4d", Radius / CELL_LEPTON_W);
	mono->Set_Cursor(71, 9);mono->Printf("%5d", (long)AITimer);

	mono->Set_Cursor(1, 11);mono->Printf("%08X", VScan);
	mono->Set_Cursor(10, 11);mono->Printf("%8.8s", (BuildVessel == VESSEL_NONE) ? " " : VesselTypeClass::As_Reference(BuildVessel).Graphic_Name());
	mono->Set_Cursor(21, 11);mono->Printf("%3d", CurVessels);
	mono->Set_Cursor(54, 11);mono->Printf("%04X", Coord_Cell(Center));
	mono->Set_Cursor(71, 11);mono->Printf("%5d", (long)DamageTime);


	for (int index = 0; index < ARRAY_SIZE(Scen.GlobalFlags); index++) {
		mono->Set_Cursor(1+index, 15);
		if (Scen.GlobalFlags[index] != 0) {
			mono->Print("1");
		} else {
			mono->Print("0");
		}
		if (index >= 24) break;
	}
	if (Enemy != HOUSE_NONE) {
		char const * name = "";
		name = HouseClass::As_Pointer(Enemy)->Name();
		mono->Set_Cursor(53, 15);mono->Printf("[%d]%21.21s", Enemy, HouseTypeClass::As_Reference(Enemy).Name());
	}

	Print_Zone_Stats(27, 11, ZONE_NORTH, mono);
	Print_Zone_Stats(27, 13, ZONE_CORE, mono);
	Print_Zone_Stats(27, 15, ZONE_SOUTH, mono);
	Print_Zone_Stats(1, 13, ZONE_WEST, mono);
	Print_Zone_Stats(53, 13, ZONE_EAST, mono);

	mono->Fill_Attrib(1, 17, 12, 1, IsActive ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(1, 18, 12, 1, IsHuman ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(1, 19, 12, 1, IsPlayerControl ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(1, 20, 12, 1, IsAlerted ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(1, 21, 12, 1, IsDiscovered ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(1, 22, 12, 1, IsMaxedOut ? MonoClass::INVERSE : MonoClass::NORMAL);

	mono->Fill_Attrib(14, 17, 12, 1, IsDefeated ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(14, 18, 12, 1, IsToDie ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(14, 19, 12, 1, IsToWin ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(14, 20, 12, 1, IsToLose ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(14, 21, 12, 1, IsCivEvacuated ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(14, 22, 12, 1, IsRecalcNeeded ? MonoClass::INVERSE : MonoClass::NORMAL);

	mono->Fill_Attrib(27, 17, 12, 1, IsVisionary ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(27, 18, 12, 1, IsTiberiumShort ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(27, 19, 12, 1, IsSpied ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(27, 20, 12, 1, IsThieved ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(27, 21, 12, 1, IsGPSActive ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(27, 22, 12, 1, IsStarted ? MonoClass::INVERSE : MonoClass::NORMAL);

	mono->Fill_Attrib(40, 17, 12, 1, IsResigner ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(40, 18, 12, 1, IsGiverUpper ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(40, 19, 12, 1, IsBuiltSomething ? MonoClass::INVERSE : MonoClass::NORMAL);
	mono->Fill_Attrib(40, 20, 12, 1, IsBaseBuilding ? MonoClass::INVERSE : MonoClass::NORMAL);
}
#endif


/***********************************************************************************************
 * HouseClass::new -- Allocator for a house class.                                             *
 *                                                                                             *
 *    This is the allocator for a house class. Since there can be only                         *
 *    one of each type of house, this is allocator has restricted                              *
 *    functionality. Any attempt to allocate a house structure for a                           *
 *    house that already exists, just returns a pointer to the previously                      *
 *    allocated house.                                                                         *
 *                                                                                             *
 * INPUT:   house -- The house to allocate a class object for.                                 *
 *                                                                                             *
 * OUTPUT:  Returns with a pointer to the allocated class object.                              *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/22/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
void * HouseClass::operator new(size_t)
{
	void * ptr = Houses.Allocate();
	if (ptr) {
		((HouseClass *)ptr)->IsActive = true;
	}
	return(ptr);
}


/***********************************************************************************************
 * HouseClass::delete -- Deallocator function for a house object.                              *
 *                                                                                             *
 *    This function marks the house object as "deallocated". Such a                            *
 *    house object is available for reallocation later.                                        *
 *                                                                                             *
 * INPUT:   ptr   -- Pointer to the house object to deallocate.                                *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/22/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::operator delete(void * ptr)
{
	if (ptr) {
		((HouseClass *)ptr)->IsActive = false;
	}
	Houses.Free((HouseClass *)ptr);
}


/***********************************************************************************************
 * HouseClass::HouseClass -- Constructor for a house object.                                   *
 *                                                                                             *
 *    This function is the constructor and it marks the house object                           *
 *    as being allocated.                                                                      *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/22/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
#define 	VOX_NOT_READY	VOX_NONE
HouseClass::HouseClass(HousesType house) :
	RTTI(RTTI_HOUSE),
	ID(Houses.ID(this)),
	Class(HouseTypes.Ptr(house)),
	Difficulty(Scen.CDifficulty),
	FirepowerBias(1),
	GroundspeedBias(1),
	AirspeedBias(1),
	ArmorBias(1),
	ROFBias(1),
	CostBias(1),
	BuildSpeedBias(1),
	RepairDelay(0),
	BuildDelay(0),
	ActLike(Class->House),
	IsHuman(false),
	IsPlayerControl(false),
	IsStarted(false),
	IsAlerted(false),
	IsBaseBuilding(false),
	IsDiscovered(false),
	IsMaxedOut(false),
	IsDefeated(false),
	IsToDie(false),
	IsToLose(false),
	IsToWin(false),
	IsCivEvacuated(false),
	IsRecalcNeeded(true),
	IsVisionary(false),
	IsTiberiumShort(false),
	IsSpied(false),
	IsThieved(false),
	IsGPSActive(false),
	IsBuiltSomething(false),
	IsResigner(false),
	IsGiverUpper(false),
	IsParanoid(false),
	IsToLook(true),
	DidRepair(false),
	IQ(Control.IQ),
	State(STATE_BUILDUP),
	JustBuiltStructure(STRUCT_NONE),
	JustBuiltInfantry(INFANTRY_NONE),
	JustBuiltUnit(UNIT_NONE),
	JustBuiltAircraft(AIRCRAFT_NONE),
	JustBuiltVessel(VESSEL_NONE),
	Blockage(0),
	RepairTimer(0),
	AlertTime(0),
	BorrowedTime(0),
	BScan(0),
	ActiveBScan(0),
	OldBScan(0),
	UScan(0),
	ActiveUScan(0),
	OldUScan(0),
	IScan(0),
	ActiveIScan(0),
	OldIScan(0),
	AScan(0),
	ActiveAScan(0),
	OldAScan(0),
	VScan(0),
	ActiveVScan(0),
	OldVScan(0),
	CreditsSpent(0),
	HarvestedCredits(0),
	StolenBuildingsCredits(0),
	CurUnits(0),
	CurBuildings(0),
	CurInfantry(0),
	CurVessels(0),
	CurAircraft(0),
	Tiberium(0),
	Credits(0),
	Capacity(0),
	AircraftTotals(NULL),
	InfantryTotals(NULL),
	UnitTotals(NULL),
	BuildingTotals(NULL),
	VesselTotals(NULL),
	DestroyedAircraft(NULL),
	DestroyedInfantry(NULL),
	DestroyedUnits(NULL),
	DestroyedBuildings(NULL),
	DestroyedVessels(NULL),
	CapturedBuildings(NULL),
	TotalCrates(NULL),
	AircraftFactories(0),
	InfantryFactories(0),
	UnitFactories(0),
	BuildingFactories(0),
	VesselFactories(0),
	Power(0),
	Drain(0),
	AircraftFactory(-1),
	InfantryFactory(-1),
	UnitFactory(-1),
	BuildingFactory(-1),
	VesselFactory(-1),
	FlagLocation(TARGET_NONE),
	FlagHome(0),
	UnitsLost(0),
	BuildingsLost(0),
	WhoLastHurtMe(house),
	Center(0),
	Radius(0),
	LATime(0),
	LAType(RTTI_NONE),
	LAZone(ZONE_NONE),
	LAEnemy(HOUSE_NONE),
	ToCapture(TARGET_NONE),
	RadarSpied(0),
	PointTotal(0),
	PreferredTarget(QUARRY_ANYTHING),
	Attack(0),
	Enemy(HOUSE_NONE),
	AITimer(0),
	UnitToTeleport(0),
	BuildStructure(STRUCT_NONE),
	BuildUnit(UNIT_NONE),
	BuildInfantry(INFANTRY_NONE),
	BuildAircraft(AIRCRAFT_NONE),
	BuildVessel(VESSEL_NONE),
	NukeDest(0),
	Allies(0),
	DamageTime(TICKS_PER_MINUTE * Rule.DamageDelay),
	TeamTime(TICKS_PER_MINUTE * Rule.TeamDelay),
	TriggerTime(0),
	SpeakAttackDelay(1),
	SpeakPowerDelay(1),
	SpeakMoneyDelay(1),
	SpeakMaxedDelay(1),
	RemapColor(Class->RemapColor)
{
	/*
	**	Explicit in-place construction of the super weapons is
	**	required here because the default constructor for super
	**	weapons must serve as a no-initialization constructor (save/load reasons).
	*/
	new (&SuperWeapon[SPC_NUCLEAR_BOMB]) SuperClass(TICKS_PER_MINUTE * Rule.NukeTime, true, VOX_ABOMB_PREPPING, VOX_ABOMB_READY, VOX_NOT_READY, VOX_INSUFFICIENT_POWER);
	new (&SuperWeapon[SPC_SONAR_PULSE]) SuperClass(TICKS_PER_MINUTE * Rule.SonarTime, false, VOX_NONE, VOX_SONAR_AVAILABLE, VOX_NOT_READY, VOX_NOT_READY);
	new (&SuperWeapon[SPC_CHRONOSPHERE]) SuperClass(TICKS_PER_MINUTE * Rule.ChronoTime, true, VOX_CHRONO_CHARGING, VOX_CHRONO_READY, VOX_NOT_READY, VOX_INSUFFICIENT_POWER);
	new (&SuperWeapon[SPC_PARA_BOMB]) SuperClass(TICKS_PER_MINUTE * Rule.ParaBombTime, false, VOX_NONE, VOX_NONE, VOX_NOT_READY, VOX_NOT_READY);
	new (&SuperWeapon[SPC_PARA_INFANTRY]) SuperClass(TICKS_PER_MINUTE * Rule.ParaInfantryTime, false, VOX_NONE, VOX_NONE, VOX_NOT_READY, VOX_NOT_READY);
	new (&SuperWeapon[SPC_SPY_MISSION]) SuperClass(TICKS_PER_MINUTE * Rule.SpyTime, false, VOX_NONE, VOX_SPY_PLANE, VOX_NOT_READY, VOX_NOT_READY);
	new (&SuperWeapon[SPC_IRON_CURTAIN]) SuperClass(TICKS_PER_MINUTE * Rule.IronCurtainTime, true, VOX_IRON_CHARGING, VOX_IRON_READY, VOX_NOT_READY, VOX_INSUFFICIENT_POWER);
	new (&SuperWeapon[SPC_GPS]) SuperClass(TICKS_PER_MINUTE * Rule.GPSTime, true, VOX_NONE, VOX_NONE, VOX_NOT_READY, VOX_INSUFFICIENT_POWER);

	memset(UnitsKilled, '\0', sizeof(UnitsKilled));
	memset(BuildingsKilled, '\0', sizeof(BuildingsKilled));
	memset(BQuantity, '\0', sizeof(BQuantity));
	memset(UQuantity, '\0', sizeof(UQuantity));
	memset(IQuantity, '\0', sizeof(IQuantity));
	memset(AQuantity, '\0', sizeof(AQuantity));
	memset(VQuantity, '\0', sizeof(VQuantity));
	strcpy(IniName, Text_String(TXT_COMPUTER));	// Default computer name.
	HouseTriggers[house].Clear();
	memset((void *)&Regions[0], 0x00, sizeof(Regions));
	Make_Ally(house);
	Assign_Handicap(Scen.CDifficulty);

	/*
	**	Set the time of the first AI attack.
	*/
	Attack = Rule.AttackDelay * Random_Pick(TICKS_PER_MINUTE/2, TICKS_PER_MINUTE*2);

	if (Session.Type == GAME_INTERNET) {
		AircraftTotals = new UnitTrackerClass( (int) AIRCRAFT_COUNT);
		InfantryTotals = new UnitTrackerClass( (int) INFANTRY_COUNT);
		UnitTotals = new UnitTrackerClass ( (int) UNIT_COUNT);
		BuildingTotals = new UnitTrackerClass ( (int) STRUCT_COUNT);
		VesselTotals = new UnitTrackerClass ( (int) VESSEL_COUNT);

		DestroyedAircraft = new UnitTrackerClass ( (int) AIRCRAFT_COUNT);
		DestroyedInfantry = new UnitTrackerClass( (int) INFANTRY_COUNT);
		DestroyedUnits = new UnitTrackerClass ( (int) UNIT_COUNT);
		DestroyedBuildings = new UnitTrackerClass ( (int) STRUCT_COUNT);
		DestroyedVessels = new UnitTrackerClass ( (int) VESSEL_COUNT);

		CapturedBuildings = new UnitTrackerClass ( (int) STRUCT_COUNT);
		TotalCrates = new UnitTrackerClass ( CRATE_COUNT );
	}
}


/***********************************************************************************************
 * HouseClass::~HouseClass -- House class destructor                                           *
 *                                                                                             *
 *                                                                                             *
 *                                                                                             *
 * INPUT:    Nothing                                                                           *
 *                                                                                             *
 * OUTPUT:   Nothing                                                                           *
 *                                                                                             *
 * WARNINGS: None                                                                              *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *    8/6/96 4:48PM ST : Created                                                               *
 *=============================================================================================*/
HouseClass::~HouseClass (void)
{
	Class = 0;

	if (Session.Type == GAME_INTERNET) {
		delete AircraftTotals;
		delete InfantryTotals;
		delete UnitTotals;
		delete BuildingTotals;
		delete VesselTotals;

		delete DestroyedAircraft;
		delete DestroyedInfantry;
		delete DestroyedUnits;
		delete DestroyedBuildings;
		delete DestroyedVessels;

		delete CapturedBuildings;
		delete TotalCrates;
	}
}


/***********************************************************************************************
 * HouseStaticClass::HouseStaticClass -- Default constructor for house static class.           *
 *                                                                                             *
 *    This is the default constructor that initializes all the values to their default         *
 *    settings.                                                                                *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/31/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
HouseStaticClass::HouseStaticClass(void) :
	IQ(0),
	TechLevel(1),
	Allies(0),
	MaxUnit(Rule.UnitMax/6),
	MaxBuilding(Rule.BuildingMax/6),
	MaxInfantry(Rule.InfantryMax/6),
	MaxVessel(Rule.VesselMax/6),
	MaxAircraft(Rule.UnitMax/6),
	InitialCredits(0),
	Edge(SOURCE_NORTH)
{
}


/***********************************************************************************************
 * HouseClass::Can_Build -- General purpose build legality checker.                            *
 *                                                                                             *
 *    This routine is called when it needs to be determined if the specified object type can   *
 *    be built by this house. Production and sidebar maintenance use this routine heavily.     *
 *                                                                                             *
 * INPUT:   type  -- Pointer to the type of object that legality is to be checked for.         *
 *                                                                                             *
 *          house -- This is the house to check for legality against. Note that this might     *
 *                   not be 'this' house since the check could be from a captured factory.     *
 *                   Captured factories build what the original owner of them could build.     *
 *                                                                                             *
 * OUTPUT:  Can the specified object be built?                                                 *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/04/1995 JLB : Created.                                                                 *
 *   08/12/1995 JLB : Updated for GDI building sandbag walls in #9.                            *
 *   10/23/1996 JLB : Hack to allow Tanya to both sides in multiplay.                          *
 *   11/04/1996 JLB : Computer uses prerequisite record.                                       *
 *=============================================================================================*/
bool HouseClass::Can_Build(ObjectTypeClass const * type, HousesType house) const
{
	assert(Houses.ID(this) == ID);
	assert(type != NULL);

	/*
	**	An object with a prohibited tech level availability will never be allowed, regardless
	**	of who requests it.
	*/
	if (((TechnoTypeClass const *)type)->Level == -1) return(false);

#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
	/*
	** If this is a CounterStrike II-only unit, and we're playing a multiplayer
	** game in 'downshifted' mode against CounterStrike or Red Alert, then
	** don't allow building this unit.
	*/
	if (!NewUnitsEnabled) {
		switch(type->What_Am_I()) {
			case RTTI_INFANTRYTYPE:
				if ( ((InfantryTypeClass *)type)->ID >= INFANTRY_RA_COUNT)
					return(false);
				break;
			case RTTI_UNITTYPE:
				if ( ((UnitTypeClass *)type)->ID >= UNIT_RA_COUNT)
					return(false);
				break;
			case RTTI_VESSELTYPE:
				if ( ((VesselTypeClass *)type)->ID >= VESSEL_RA_COUNT)
					return(false);
				break;
			default:
				break;
		}
	}
#endif

	/*
	**	The computer can always build everything.
	*/
	if (!IsHuman && Session.Type == GAME_NORMAL) return(true);

	/*
	**	Special hack to get certain objects to exist for both sides in the game.
	*/
	int own = type->Get_Ownable();

	/*
	**	Check to see if this owner can build the object type specified.
	*/
	if (((1L << house) & own) == 0) {
		return(false);
	}

	/*
	**	Perform some equivalency fixups for the building existence flags.
	*/
	long flags = ActiveBScan;

	/*
	**	The computer records prerequisite buildings because it can't relay on the
	**	sidebar to keep track of this information.
	*/
	if (!IsHuman) {
		flags = OldBScan;
	}

	int pre = ((TechnoTypeClass const *)type)->Prerequisite;

	/*
	**	Advanced power also serves as a prerequisite for normal power.
	*/
	if (flags & STRUCTF_ADVANCED_POWER) flags |= STRUCTF_POWER;

	/*
	**	Either tech center counts as a prerequisite.
	*/
	if (Session.Type != GAME_NORMAL) {
		if ((flags & (STRUCTF_SOVIET_TECH|STRUCTF_ADVANCED_TECH)) != 0) flags |= STRUCTF_SOVIET_TECH|STRUCTF_ADVANCED_TECH;
	}

	int level = Control.TechLevel;
#ifdef CHEAT_KEYS
	if (Debug_Cheat) {
		level = 98;
		pre = 0;
	}
#endif

	/*
	**	See if the prerequisite requirements have been met.
	*/
	return((pre & flags) == pre && ((TechnoTypeClass const *)type)->Level <= level);
}


/***************************************************************************
 * HouseClass::Init -- init's in preparation for new scenario              *
 *                                                                         *
 * INPUT:                                                                  *
 *      none.                                                              *
 *                                                                         *
 * OUTPUT:                                                                 *
 *      none.                                                              *
 *                                                                         *
 * WARNINGS:                                                               *
 *      none.                                                              *
 *                                                                         *
 * HISTORY:                                                                *
 *   12/07/1994 BR : Created.                                              *
 *   12/17/1994 JLB : Resets tracker bits.                                 *
 *=========================================================================*/
void HouseClass::Init(void)
{
	Houses.Free_All();

	for (HousesType index = HOUSE_FIRST; index < HOUSE_COUNT; index++) {
		HouseTriggers[index].Clear();
	}
}


/***********************************************************************************************
 * HouseClass::AI -- Process house logic.                                                      *
 *                                                                                             *
 *    This handles the AI for the house object. It should be called once per house per game    *
 *    tick. It processes all house global tasks such as low power damage accumulation and      *
 *    house specific trigger events.                                                           *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/27/1994 JLB : Created.                                                                 *
 *   07/17/1995 JLB : Limits EVA speaking unless the player can do something.                  *
 *=============================================================================================*/
void HouseClass::AI(void)
{
	assert(Houses.ID(this) == ID);

	/*
	**	If base building has been turned on by a trigger, then force the house to begin
	**	production and team creation as well. This is also true if the IQ is high enough to
	**	being base building.
	*/
	if (IsBaseBuilding || IQ >= Rule.IQProduction) {
		IsBaseBuilding = true;
		IsStarted = true;
		IsAlerted = true;
	}

	/*
	**	Check to see if the house wins.
	*/
	if (Session.Type == GAME_NORMAL && IsToWin && BorrowedTime == 0 && Blockage <= 0) {
		IsToWin = false;
		if (this == PlayerPtr) {
			PlayerWins = true;
		} else {
			PlayerLoses = true;
		}
	}

	/*
	**	Check to see if the house loses.
	*/
	if (Session.Type == GAME_NORMAL && IsToLose && BorrowedTime == 0) {
		IsToLose = false;
		if (this == PlayerPtr) {
			PlayerLoses = true;
		} else {
			PlayerWins = true;
		}
	}

	/*
	**	Check to see if all objects of this house should be blown up.
	*/
	if (IsToDie && BorrowedTime == 0) {
		IsToDie = false;
		Blowup_All();
	}

	/*
	**	Double check power values to correct illegal conditions. It is possible to
	**	get a power output of negative (one usually) as a result of damage sustained
	**	and the fixed point fractional math involved with power adjustments. If the
	**	power rating drops below zero, then make it zero.
	*/
	Power = max(Power, 0);
	Drain = max(Drain, 0);

	/*
	**	If the base has been alerted to the enemy and should be attacking, then
	**	see if the attack timer has expired. If it has, then create the attack
	**	teams.
	*/
	if (IsAlerted && AlertTime == 0) {

		/*
		**	Adjusted to reduce maximum number of teams created.
		*/
		int maxteams = Random_Pick(2, (int)(((Control.TechLevel-1)/3)+1));
		for (int index = 0; index < maxteams; index++) {
			TeamTypeClass const * ttype = Suggested_New_Team(true);
			if (ttype != NULL) {
				ScenarioInit++;
				ttype->Create_One_Of();
				ScenarioInit--;
			}
		}
		AlertTime = Rule.AutocreateTime * Random_Pick(TICKS_PER_MINUTE/2, TICKS_PER_MINUTE*2);
//		int mintime = Rule.AutocreateTime * (TICKS_PER_MINUTE/2);
//		int maxtime = Rule.AutocreateTime * (TICKS_PER_MINUTE*2);
//		AlertTime = Random_Pick(mintime, maxtime);
	}

	/*
	**	If this house's flag waypoint is a valid cell, see if there's
	**	someone sitting on it.  If so, make the scatter.  If they refuse,
	**	blow them up.
	*/
	if (FlagHome != 0 && (Frame % TICKS_PER_SECOND) == 0) {

		TechnoClass * techno = Map[FlagHome].Cell_Techno();
		if (techno != NULL) {
			bool moving = false;
			if (techno->Is_Foot()) {
				if (Target_Legal(((FootClass *)techno)->NavCom)) {
					moving = true;
				}
			}

			if (!moving) {
				techno->Scatter(0, true, true);
			}

			/*
			**	If the techno doesn't have a valid NavCom, he's not moving,
			**	so blow him up.
			*/
			if (techno->Is_Foot()) {
				if (Target_Legal(((FootClass *)techno)->NavCom)) {
					moving = true;
				}
			}

			/*
			**	If the techno wasn't an infantry or unit (ie he's a building),
			**	or he refuses to move, blow him up
			*/
			if (!moving) {
				int count = 0;
				while (!(techno->IsInLimbo) && count++ < 5) {
					int damage = techno->Strength;
					techno->Take_Damage(damage, 0, WARHEAD_HE, NULL, true);
				}
			}
		}
	}

	/*
	**	Create teams for this house if necessary.
	** (Use the same timer for some extra capture-the-flag logic.)
	*/
	if (!IsAlerted && !TeamTime) {

		TeamTypeClass const * ttype = Suggested_New_Team(false);
		if (ttype) {
			ttype->Create_One_Of();
		}

		TeamTime = Rule.TeamDelay * TICKS_PER_MINUTE;
	}

	/*
	**	If there is insufficient power, then all buildings that are above
	**	half strength take a little bit of damage.
	*/
	if (DamageTime == 0) {

		/*
		**	When the power is below required, then the buildings will take damage over
		**	time.
		*/
		if (Power_Fraction() < 1) {
			for (int index = 0; index < Buildings.Count(); index++) {
				BuildingClass & b = *Buildings.Ptr(index);

				if (b.House == this && b.Health_Ratio() > Rule.ConditionYellow) {
					// BG: Only damage buildings that require power, to keep the
					//     land mines from blowing up under low-power conditions
					if (b.Class->Drain) {
						int damage = 1;
						b.Take_Damage(damage, 0, WARHEAD_AP, 0);
					}
				}
			}
		}
		DamageTime = TICKS_PER_MINUTE * Rule.DamageDelay;
	}

	/*
	**	If there are no more buildings to sell, then automatically cancel the
	**	sell mode.
	*/
	if (PlayerPtr == this && !ActiveBScan && Map.IsSellMode) {
		Map.Sell_Mode_Control(0);
	}

	/*
	**	Various base conditions may be announced to the player. Typically, this would be
	**	low tiberium capacity or low power.
	*/
	if (PlayerPtr == this) {

		if (SpeakMaxedDelay == 0 && Available_Money() < 100 && UnitFactories+BuildingFactories+InfantryFactories > 0) {
			Speak(VOX_NEED_MO_MONEY);
			Map.Flash_Money();
			SpeakMaxedDelay = Options.Normalize_Delay(TICKS_PER_MINUTE * Rule.SpeakDelay);
		}

		if (SpeakMaxedDelay == 0 && IsMaxedOut) {
			IsMaxedOut = false;
			if ((Capacity - Tiberium) < 300 && Capacity > 500 && (ActiveBScan & (STRUCTF_REFINERY | STRUCTF_CONST))) {
 				Speak(VOX_NEED_MO_CAPACITY);
				SpeakMaxedDelay = Options.Normalize_Delay(TICKS_PER_MINUTE * Rule.SpeakDelay);
			}
		}
		if (SpeakPowerDelay == 0 && Power_Fraction() < 1) {
			if (ActiveBScan & STRUCTF_CONST) {
				Speak(VOX_LOW_POWER);
				SpeakPowerDelay = Options.Normalize_Delay(TICKS_PER_MINUTE * Rule.SpeakDelay);
				Map.Flash_Power();

				char const * text = NULL;
				if (BQuantity[STRUCT_AAGUN] > 0) {
					text = Text_String(TXT_POWER_AAGUN);
				}
				if (BQuantity[STRUCT_TESLA] > 0) {
					text = Text_String(TXT_POWER_TESLA);
				}
				if (text == NULL) {
					text = Text_String(TXT_LOW_POWER);
				}
				if (text != NULL) {
					Session.Messages.Add_Message(NULL, 0, text, PCOLOR_GREEN, TPF_6PT_GRAD|TPF_USE_GRAD_PAL|TPF_FULLSHADOW, Rule.MessageDelay * TICKS_PER_MINUTE);
				}
			}
		}
	}

	/*
	**	If there is a flag associated with this house, then mark it to be
	**	redrawn.
	*/
	if (Target_Legal(FlagLocation)) {
		UnitClass * unit = As_Unit(FlagLocation);
		if (unit) {
			unit->Mark(MARK_CHANGE);
		} else {
			CELL cell = As_Cell(FlagLocation);
			Map[cell].Redraw_Objects();
		}
	}

	bool is_time = false;

	/*
	**	Triggers are only checked every so often. If the trigger timer has expired,
	**	then set the trigger processing flag.
	*/
	if (TriggerTime == 0 || IsBuiltSomething) {
		is_time = true;
		TriggerTime = TICKS_PER_MINUTE/10;
		IsBuiltSomething = false;
	}

	/*
	**	Process any super weapon logic required.
	*/
	Super_Weapon_Handler();

#ifdef FIXIT_VERSION_3			//	For endgame auto-sonar pulse.
	if( Scen.AutoSonarTimer == 0 )
	{
		//	If house has nothing but subs left, do an automatic sonar pulse to reveal them.
		if( VQuantity[ VESSEL_SS ] > 0 )		//	Includes count of VESSEL_MISSILESUBs. ajw
		{
			int iCount = 0;
			for( int i = 0; i != STRUCT_COUNT-3; ++i )
			{
				iCount += BQuantity[ i ];
			}
			if( !iCount )
			{
				for( i = 0; i != UNIT_RA_COUNT-3; ++i )
				{
					iCount += UQuantity[ i ];
				}
				if( !iCount )
				{
					//	ajw - Found bug - house's civilians are not removed from IQuantity when they die.
					//	Workaround...
					for( i = 0; i <= INFANTRY_DOG; ++i )
					{
						iCount += IQuantity[ i ];
					}
					if( !iCount )
					{
						for( i = 0; i != AIRCRAFT_COUNT; ++i )
						{
							iCount += AQuantity[ i ];
						}
						if( !iCount )
						{
							for( i = 0; i != VESSEL_RA_COUNT; ++i )
							{
								if( i != VESSEL_SS )
									iCount += VQuantity[ i ];
							}
							if( !iCount )
							{
								//	Do the ping.
								for (int index = 0; index < Vessels.Count(); index++) {
									VesselClass * sub = Vessels.Ptr(index);
									if (*sub == VESSEL_SS || *sub == VESSEL_MISSILESUB) {
										sub->PulseCountDown = 15 * TICKS_PER_SECOND;
										sub->Do_Uncloak();
									}
								}
								bAutoSonarPulse = true;
							}
						}
					}
				}
			}
		}
	}
#endif

	/*
	** Special win/lose check for multiplayer games; by-passes the
	** trigger system.  We must wait for non-zero frame, because init
	** may not properly set IScan etc for each house; you have to go
	** through each object's AI before it will be properly set.
	*/
	if (Session.Type != GAME_NORMAL && !IsDefeated &&
		!ActiveBScan && !ActiveAScan && !UScan && !ActiveIScan && !ActiveVScan && Frame > 0) {
		MPlayer_Defeated();
	}

	/*
	**	Try to spring all events attached to this house. The triggers will check
	**	for themselves if they actually need to be sprung or not.
	*/
	for (int index = 0; index < HouseTriggers[Class->House].Count(); index++) {
		if (HouseTriggers[Class->House][index]->Spring() && index > 0) {
			index--;
			continue;
		}
	}

	/*
	**	If a radar facility is not present, but the radar is active, then turn the radar off.
	**	The radar also is turned off when the power gets below 100% capacity.
	*/
	if (PlayerPtr == this) {
		bool jammed = Map.Is_Radar_Active();

		/*
		** Find if there are any radar facilities, and if they're jammed or not
		*/

		if (IsGPSActive) {
			jammed = false;
		} else {
			for (int index = 0; index < Buildings.Count(); index++) {
				BuildingClass * building = Buildings.Ptr(index);
#ifdef FIXIT_RADAR_JAMMED
				if (building != NULL && !building->IsInLimbo && building->House == PlayerPtr) {
#else
				if (building && building->House == PlayerPtr) {
#endif
					if (*building == STRUCT_RADAR /* || *building == STRUCT_EYE */) {
						if (!building->IsJammed) {
							jammed = false;
							break;
						}
					}
				}
			}
		}

		if (Map.Get_Jammed() != jammed) {
			Map.RadarClass::Flag_To_Redraw(true);
		}
		Map.Set_Jammed(jammed);
// Need to add in here where we activate it when only GPS is active.
		if (Map.Is_Radar_Active()) {
			if (ActiveBScan & STRUCTF_RADAR) {
				if (Power_Fraction() < 1 && !IsGPSActive) {
					Map.Radar_Activate(0);
				}
			} else {
				if (!IsGPSActive) {
					Map.Radar_Activate(0);
				}
			}

		} else {
			if (IsGPSActive || (ActiveBScan & STRUCTF_RADAR)) {
				if (Power_Fraction() >= 1 || IsGPSActive) {
					Map.Radar_Activate(1);
				}
			} else {
				if (Map.Is_Radar_Existing()) {
					Map.Radar_Activate(4);
				}
			}
		}
	}

	/*
	**	Perform any expert system AI processing.
	*/
	if (IsBaseBuilding && AITimer == 0) {
		AITimer = Expert_AI();
	}

	if (!IsBaseBuilding && State == STATE_ENDGAME) {
		Fire_Sale();
		Do_All_To_Hunt();
	}

	AI_Building();
	AI_Unit();
	AI_Vessel();
	AI_Infantry();
	AI_Aircraft();


	/*
	**	If the production possibilities need to be recalculated, then do so now. This must
	**	occur after the scan bits have been properly updated.
	*/
	if (PlayerPtr == this && IsRecalcNeeded) {
		IsRecalcNeeded = false;
		Map.Recalc();

		/*
		**	This placement might affect any prerequisite requirements for construction
		**	lists. Update the buildable options accordingly.
		*/
		for (int index = 0; index < Buildings.Count(); index++) {
			BuildingClass * building = Buildings.Ptr(index);
			if (building && building->Strength > 0 && building->Owner() == Class->House && building->Mission != MISSION_DECONSTRUCTION && building->MissionQueue != MISSION_DECONSTRUCTION) {

				if (PlayerPtr == building->House) {
					building->Update_Buildables();
				}
			}
		}
	}

	/*
	** See if it's time to re-set the can-repair flag
	*/
	if (DidRepair && RepairTimer == 0) {
		DidRepair = false;
	}

	if (this == PlayerPtr && IsToLook) {
		IsToLook = false;
		Map.All_To_Look();
	}
}


/***********************************************************************************************
 * HouseClass::Super_Weapon_Handler -- Handles the super weapon charge and discharge logic.    *
 *                                                                                             *
 *    This handles any super weapons assigned to this house. It also performs any necessary    *
 *    maintenance that the super weapons require.                                              *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/17/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Super_Weapon_Handler(void)
{
	/*
	**	Perform all super weapon AI processing. This just checks to see if
	**	the graphic needs changing for the special weapon and updates the
	**	sidebar as necessary.
	*/
	for (SpecialWeaponType special = SPC_FIRST; special < SPC_COUNT; special++) {
		SuperClass * super = &SuperWeapon[special];

		if (super->Is_Present()) {

			/*
			**	Perform any charge-up logic for the super weapon. If the super
			**	weapon is owned by the player and a graphic change is detected, then
			**	flag the sidebar to be redrawn so the player will see the change.
			*/
			if (super->AI(this == PlayerPtr)) {
				if (this == PlayerPtr) Map.Column[1].Flag_To_Redraw();
			}

			/*
			**	Repeating super weapons that require power will be suspended if there
			**	is insufficient power available.
			*/
			if (!super->Is_Ready() && super->Is_Powered() && !super->Is_One_Time()) {
				super->Suspend(Power_Fraction() < 1);
			}
		}
	}

	/*
	** Check to see if they have launched the GPS, but subsequently lost their
	** tech center.  If so, remove the GPS, and shroud the map.
	*/
	if (IsGPSActive && !(ActiveBScan & STRUCTF_ADVANCED_TECH) ) {
		IsGPSActive = false;
		if (IsPlayerControl) {
			Map.Shroud_The_Map();
		}
	}

	/*
	**	Check to see if the GPS Satellite should be removed from the sidebar
	**	because of outside circumstances. The advanced technology facility
	**	being destroyed is a good example of this.  Having fired the satellite
	** is another good example, because it's a one-shot item.
	*/
	if (SuperWeapon[SPC_GPS].Is_Present()) {
		if (!(ActiveBScan & STRUCTF_ADVANCED_TECH) || IsGPSActive || IsDefeated) {
			/*
			**	Remove the missile capability when there is no advanced tech facility.
			*/
			if (SuperWeapon[SPC_GPS].Remove()) {
				if (this == PlayerPtr) Map.Column[1].Flag_To_Redraw();
				IsRecalcNeeded = true;
			}
		} else {
			/*
			** Auto-fire the GPS satellite if it's charged up.
			*/
			if (SuperWeapon[SPC_GPS].Is_Ready()) {
				SuperWeapon[SPC_GPS].Discharged(this == PlayerPtr);
				if (SuperWeapon[SPC_GPS].Remove()) {
					if (this == PlayerPtr) Map.Column[1].Flag_To_Redraw();
				}
				IsRecalcNeeded = true;
				for (int index = 0; index < Buildings.Count(); index++) {
					BuildingClass * bldg = Buildings.Ptr(index);
					if (*bldg == STRUCT_ADVANCED_TECH && bldg->House == this) {
						bldg->HasFired = true;
						bldg->Assign_Mission(MISSION_MISSILE);
						break;
					}
				}
			}
		}
	} else {
		/*
		**	If there is no GPS satellite present, but there is a GPS satellite
		**	facility available, then make the GPS satellite available as well.
		*/
		if ((ActiveBScan & STRUCTF_ADVANCED_TECH) != 0 &&
			!IsGPSActive &&
			Control.TechLevel >= Rule.GPSTechLevel &&
			(IsHuman || IQ >= Rule.IQSuperWeapons)) {

			bool canfire = false;
			for (int index = 0; index < Buildings.Count(); index++) {
				BuildingClass * bldg = Buildings.Ptr(index);
				if (*bldg == STRUCT_ADVANCED_TECH && bldg->House == this && !bldg->IsInLimbo) {
					if (!bldg->HasFired) {
						canfire = true;
						break;
					}
				}
			}

			if (canfire) {
				SuperWeapon[SPC_GPS].Enable(false, this == PlayerPtr, Power_Fraction() < 1);

				/*
				**	Flag the sidebar to be redrawn if necessary.
				*/
				if (this == PlayerPtr) {
					Map.Add(RTTI_SPECIAL, SPC_GPS);
					Map.Column[1].Flag_To_Redraw();
				}
			}
		}
	}

	/*
	**	Check to see if the chronosphere should be removed from the sidebar
	**	because of outside circumstances. The chronosphere facility
	**	being destroyed is a good example of this.
	*/
	if (SuperWeapon[SPC_CHRONOSPHERE].Is_Present()) {
		if ( (!(ActiveBScan & STRUCTF_CHRONOSPHERE) && !SuperWeapon[SPC_CHRONOSPHERE].Is_One_Time()) || IsDefeated) {

			/*
			**	Remove the chronosphere when there is no chronosphere facility.
			**	Note that this will not remove the one time created chronosphere.
			*/
			if (SuperWeapon[SPC_CHRONOSPHERE].Remove()) {
				if (this == PlayerPtr) {
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
					if (Map.IsTargettingMode == SPC_CHRONOSPHERE || Map.IsTargettingMode == SPC_CHRONO2) {
						if (Map.IsTargettingMode == SPC_CHRONO2) {
							TechnoClass * tech = (TechnoClass *)::As_Object(UnitToTeleport);
							if (tech && tech->IsActive && tech->What_Am_I() == RTTI_UNIT && *(UnitClass *)tech == UNIT_CHRONOTANK) {
							} else {
								 Map.IsTargettingMode = SPC_NONE;
							}
						} else {
							Map.IsTargettingMode = SPC_NONE;
						}
					}
#else
					if (Map.IsTargettingMode == SPC_CHRONOSPHERE ||
						 Map.IsTargettingMode == SPC_CHRONO2) {
						 Map.IsTargettingMode = SPC_NONE;
					}
#endif
					Map.Column[1].Flag_To_Redraw();
				}
				IsRecalcNeeded = true;
			}
		}
	} else {
		/*
		**	If there is no chronosphere present, but there is a chronosphere
		**	facility available, then make the chronosphere available as well.
		*/
		if ((ActiveBScan & STRUCTF_CHRONOSPHERE) &&
//			(ActLike == HOUSE_GOOD || Session.Type != GAME_NORMAL) &&
			Control.TechLevel >= BuildingTypeClass::As_Reference(STRUCT_CHRONOSPHERE).Level &&
//			Control.TechLevel >= Rule.ChronoTechLevel &&
			(IsHuman || IQ >= Rule.IQSuperWeapons)) {

			SuperWeapon[SPC_CHRONOSPHERE].Enable(false, this == PlayerPtr, Power_Fraction() < 1);

			/*
			**	Flag the sidebar to be redrawn if necessary.
			*/
			if (this == PlayerPtr) {
				Map.Add(RTTI_SPECIAL, SPC_CHRONOSPHERE);
				Map.Column[1].Flag_To_Redraw();
			}
		}
	}

	/*
	**	Check to see if the iron curtain should be removed from the sidebar
	**	because of outside circumstances. The iron curtain facility
	**	being destroyed is a good example of this.
	*/
	if (SuperWeapon[SPC_IRON_CURTAIN].Is_Present()) {
		if ( (!(ActiveBScan & STRUCTF_IRON_CURTAIN) && !SuperWeapon[SPC_IRON_CURTAIN].Is_One_Time())  || IsDefeated) {

			/*
			**	Remove the iron curtain when there is no iron curtain facility.
			**	Note that this will not remove the one time created iron curtain.
			*/
			if (SuperWeapon[SPC_IRON_CURTAIN].Remove()) {
				if (this == PlayerPtr) {
					if (Map.IsTargettingMode == SPC_IRON_CURTAIN) {
						 Map.IsTargettingMode = SPC_NONE;
					}
					Map.Column[1].Flag_To_Redraw();
				}
				IsRecalcNeeded = true;
			}
		}
	} else {
		/*
		**	If there is no iron curtain present, but there is an iron curtain
		**	facility available, then make the iron curtain available as well.
		*/
		if ((ActiveBScan & STRUCTF_IRON_CURTAIN) &&
			(ActLike == HOUSE_USSR || ActLike == HOUSE_UKRAINE || Session.Type != GAME_NORMAL) &&
			(IsHuman || IQ >= Rule.IQSuperWeapons)) {

			SuperWeapon[SPC_IRON_CURTAIN].Enable(false, this == PlayerPtr, Power_Fraction() < 1);

			/*
			**	Flag the sidebar to be redrawn if necessary.
			*/
			if (this == PlayerPtr) {
				Map.Add(RTTI_SPECIAL, SPC_IRON_CURTAIN);
				Map.Column[1].Flag_To_Redraw();
			}
		}
	}

	/*
	**	Check to see if the sonar pulse should be removed from the sidebar
	**	because of outside circumstances. The spied-upon enemy sub pen
	**	being destroyed is a good example of this.
	*/
	if (SuperWeapon[SPC_SONAR_PULSE].Is_Present()) {
		int usspy = 1 << (Class->House);
		bool present = false;
		bool powered = false;
		for (int q = 0; q < Buildings.Count() && !powered; q++) {
			BuildingClass * bldg = Buildings.Ptr(q);
			if ((*bldg == STRUCT_SUB_PEN) && (bldg->House->Class->House != Class->House) && (bldg->SpiedBy & usspy) ) {
				present = true;
				powered = !(bldg->House->Power_Fraction() < 1);
			}
		}
		if ( (!present && !SuperWeapon[SPC_SONAR_PULSE].Is_One_Time())  || IsDefeated) {

			/*
			**	Remove the sonar pulse when there is no spied-upon enemy sub pen.
			**	Note that this will not remove the one time created sonar pulse.
			*/
			if (SuperWeapon[SPC_SONAR_PULSE].Remove()) {
				if (this == PlayerPtr) Map.Column[1].Flag_To_Redraw();
				IsRecalcNeeded = true;
			}
		}
	}

	/*
	**	Check to see if the nuclear weapon should be removed from the sidebar
	**	because of outside circumstances. The missile silos
	**	being destroyed is a good example of this.
	*/
	if (SuperWeapon[SPC_NUCLEAR_BOMB].Is_Present()) {
		if ( (!(ActiveBScan & STRUCTF_MSLO) && !SuperWeapon[SPC_NUCLEAR_BOMB].Is_One_Time()) || IsDefeated) {

			/*
			**	Remove the nuke when there is no missile silo.
			**	Note that this will not remove the one time created nuke.
			*/
			if (SuperWeapon[SPC_NUCLEAR_BOMB].Remove()) {
				if (this == PlayerPtr) {
					if (Map.IsTargettingMode == SPC_NUCLEAR_BOMB) {
						 Map.IsTargettingMode = SPC_NONE;
					}
					Map.Column[1].Flag_To_Redraw();
				}
				IsRecalcNeeded = true;
			}
		} else {
			/*
			**	Allow the computer to fire the nuclear weapon when the weapon is
			**	ready and the owner is the computer.
			*/
			if (SuperWeapon[SPC_NUCLEAR_BOMB].Is_Ready() && !IsHuman) {
				Special_Weapon_AI(SPC_NUCLEAR_BOMB);
			}
		}

	} else {
		/*
		**	If there is no nuclear missile present, but there is a missile
		**	silo available, then make the missile available as well.
		*/
		if ((ActiveBScan & STRUCTF_MSLO) &&
			((ActLike != HOUSE_USSR && ActLike != HOUSE_UKRAINE) || Session.Type != GAME_NORMAL) &&
			(IsHuman || IQ >= Rule.IQSuperWeapons)) {

			SuperWeapon[SPC_NUCLEAR_BOMB].Enable(false, this == PlayerPtr, Power_Fraction() < 1);

			/*
			**	Flag the sidebar to be redrawn if necessary.
			*/
			if (this == PlayerPtr) {
				Map.Add(RTTI_SPECIAL, SPC_NUCLEAR_BOMB);
				Map.Column[1].Flag_To_Redraw();
			}
		}
	}


	if (SuperWeapon[SPC_SPY_MISSION].Is_Present()) {
		if ((ActiveBScan & STRUCTF_AIRSTRIP) == 0) {
			if (SuperWeapon[SPC_SPY_MISSION].Remove()) {
				if (this == PlayerPtr) Map.Column[1].Flag_To_Redraw();
				IsRecalcNeeded = true;
			}
		} else {
			if (this == PlayerPtr && !SuperWeapon[SPC_SPY_MISSION].Is_Ready()) {
				Map.Column[1].Flag_To_Redraw();
			}
			if (SuperWeapon[SPC_SPY_MISSION].Is_Ready() && !IsHuman) {
				Special_Weapon_AI(SPC_SPY_MISSION);
			}
		}
	} else {
		if ((ActiveBScan & STRUCTF_AIRSTRIP) != 0 && !Scen.IsNoSpyPlane && Control.TechLevel >= Rule.SpyPlaneTechLevel) {
			SuperWeapon[SPC_SPY_MISSION].Enable(false, this == PlayerPtr, false);
			if (this == PlayerPtr) {
				Map.Add(RTTI_SPECIAL, SPC_SPY_MISSION);
				Map.Column[1].Flag_To_Redraw();
			}
		}
	}

	if (SuperWeapon[SPC_PARA_BOMB].Is_Present()) {
		if ((ActiveBScan & STRUCTF_AIRSTRIP) == 0) {
			if (SuperWeapon[SPC_PARA_BOMB].Remove()) {
				if (this == PlayerPtr) Map.Column[1].Flag_To_Redraw();
				IsRecalcNeeded = true;
			}
		} else {
			if (SuperWeapon[SPC_PARA_BOMB].Is_Ready() && !IsHuman) {
				Special_Weapon_AI(SPC_PARA_BOMB);
			}
		}
	} else {
		if ((ActiveBScan & STRUCTF_AIRSTRIP) != 0 && Control.TechLevel >= Rule.ParaBombTechLevel && Session.Type == GAME_NORMAL) {
			SuperWeapon[SPC_PARA_BOMB].Enable(false, this == PlayerPtr, false);
			if (this == PlayerPtr) {
				Map.Add(RTTI_SPECIAL, SPC_PARA_BOMB);
				Map.Column[1].Flag_To_Redraw();
			}
		}
	}

	if (SuperWeapon[SPC_PARA_INFANTRY].Is_Present()) {
		if ((ActiveBScan & STRUCTF_AIRSTRIP) == 0) {
			if (SuperWeapon[SPC_PARA_INFANTRY].Remove()) {
				if (this == PlayerPtr) Map.Column[1].Flag_To_Redraw();
				IsRecalcNeeded = true;
			}
		} else {
			if (SuperWeapon[SPC_PARA_INFANTRY].Is_Ready() && !IsHuman) {
				Special_Weapon_AI(SPC_PARA_INFANTRY);
			}
		}
	} else {
		if ((ActiveBScan & STRUCTF_AIRSTRIP) != 0 && Control.TechLevel >= Rule.ParaInfantryTechLevel) {
			SuperWeapon[SPC_PARA_INFANTRY].Enable(false, this == PlayerPtr, false);
			if (this == PlayerPtr) {
				Map.Add(RTTI_SPECIAL, SPC_PARA_INFANTRY);
				Map.Column[1].Flag_To_Redraw();
			}
		}
	}
}


/***********************************************************************************************
 * HouseClass::Attacked -- Lets player know if base is under attack.                           *
 *                                                                                             *
 *    Call this function whenever a building is attacked (with malice). This function will     *
 *    then announce to the player that his base is under attack. It checks to make sure that   *
 *    this is referring to the player's house rather than the enemy's.                         *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/27/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Attacked(void)
{
	assert(Houses.ID(this) == ID);

#ifdef FIXIT_BASE_ANNOUNCE
	if (SpeakAttackDelay == 0 && ((Session.Type == GAME_NORMAL && IsPlayerControl) || PlayerPtr->Class->House == Class->House)) {
#else
	if (SpeakAttackDelay == 0 && PlayerPtr->Class->House == Class->House) {
#endif
		Speak(VOX_BASE_UNDER_ATTACK);
		SpeakAttackDelay = Options.Normalize_Delay(TICKS_PER_MINUTE * Rule.SpeakDelay);

		/*
		**	If there is a trigger event associated with being attacked, process it
		**	now.
		*/
		for (int index = 0; index < HouseTriggers[Class->House].Count(); index++) {
			HouseTriggers[Class->House][index]->Spring(TEVENT_ATTACKED);
		}
	}
}


/***********************************************************************************************
 * HouseClass::Harvested -- Adds Tiberium to the harvest storage.                              *
 *                                                                                             *
 *    Use this routine whenever Tiberium is harvested. The Tiberium is stored equally between  *
 *    all storage capable buildings for the house. Harvested Tiberium adds to the credit       *
 *    value of the house, but only up to the maximum storage capacity that the house can       *
 *    currently maintain.                                                                      *
 *                                                                                             *
 * INPUT:   tiberium -- The number of Tiberium credits to add to the House's total.            *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/25/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Harvested(unsigned tiberium)
{
	assert(Houses.ID(this) == ID);

	long oldtib = Tiberium;

	Tiberium += tiberium;
	if (Tiberium > Capacity) {
		Tiberium = Capacity;
		IsMaxedOut = true;
	}
	HarvestedCredits += tiberium;
	Silo_Redraw_Check(oldtib, Capacity);
}


/***********************************************************************************************
 * HouseClass::Stole -- Accounts for the value of a captured building.								  *
 *                                                                                             *
 *    Use this routine whenever a building is captured.  It keeps track of the cost of the     *
 *    building for use in the scoring routine, because you get an 'economy' boost for the      *
 *    value of the stolen building (but you don't get the credit value for it.)                *
 *                                                                                             *
 * INPUT:   worth -- The worth of the building we captured (stole).            					  *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/05/1996 BWG : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Stole(unsigned worth)
{
	assert(Houses.ID(this) == ID);

	StolenBuildingsCredits += worth;
}


/***********************************************************************************************
 * HouseClass::Available_Money -- Fetches the total credit worth of the house.                 *
 *                                                                                             *
 *    Use this routine to determine the total credit value of the house. This is the sum of    *
 *    the harvested Tiberium in storage and the initial unspent cash reserves.                 *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the total credit value of the house.                                  *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/25/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
long HouseClass::Available_Money(void) const
{
	assert(Houses.ID(this) == ID);

	return(Tiberium + Credits);
}


/***********************************************************************************************
 * HouseClass::Spend_Money -- Removes money from the house.                                    *
 *                                                                                             *
 *    Use this routine to extract money from the house. Typically, this is a result of         *
 *    production spending. The money is extracted from available cash reserves first. When     *
 *    cash reserves are exhausted, then Tiberium is consumed.                                  *
 *                                                                                             *
 * INPUT:   money -- The amount of money to spend.                                             *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/25/1995 JLB : Created.                                                                 *
 *   06/20/1995 JLB : Spends Tiberium before spending cash.                                    *
 *=============================================================================================*/
void HouseClass::Spend_Money(unsigned money)
{
	assert(Houses.ID(this) == ID);

	long oldtib = Tiberium;
	if (money > Tiberium) {
		money -= (unsigned)Tiberium;
		Tiberium = 0;
		Credits -= money;
	} else {
		Tiberium -= money;
	}
	Silo_Redraw_Check(oldtib, Capacity);
	CreditsSpent += money;
}


/***********************************************************************************************
 * HouseClass::Refund_Money -- Refunds money to back to the house.                             *
 *                                                                                             *
 *    Use this routine when money needs to be refunded back to the house. This can occur when  *
 *    construction is aborted. At this point, the exact breakdown of Tiberium or initial       *
 *    credits used for the orignal purchase is lost. Presume as much of the money is in the    *
 *    form of Tiberium as storage capacity will allow.                                         *
 *                                                                                             *
 * INPUT:   money -- The number of credits to refund back to the house.                        *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/25/1995 JLB : Created.                                                                 *
 *   06/01/1995 JLB : Refunded money is never lost                                             *
 *=============================================================================================*/
void HouseClass::Refund_Money(unsigned money)
{
	assert(Houses.ID(this) == ID);

	Credits += money;
}


/***********************************************************************************************
 * HouseClass::Adjust_Capacity -- Adjusts the house Tiberium storage capacity.                 *
 *                                                                                             *
 *    Use this routine to adjust the maximum storage capacity for the house. This storage      *
 *    capacity will limit the number of Tiberium credits that can be stored at any one time.   *
 *                                                                                             *
 * INPUT:   adjust   -- The adjustment to the Tiberium storage capacity.                       *
 *                                                                                             *
 *          inanger  -- Is this a forced adjustment to capacity due to some hostile event?     *
 *                                                                                             *
 * OUTPUT:  Returns with the number of Tiberium credits lost.                                  *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/25/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
int HouseClass::Adjust_Capacity(int adjust, bool inanger)
{
	assert(Houses.ID(this) == ID);

	long oldcap = Capacity;
	int retval = 0;

	Capacity += adjust;
	Capacity = max(Capacity, 0L);
	if (Tiberium > Capacity) {
		retval = Tiberium - Capacity;
		Tiberium = Capacity;
		if (!inanger) {
			Refund_Money(retval);
			retval = 0;
		} else {
			IsMaxedOut = true;
		}
	}
	Silo_Redraw_Check(Tiberium, oldcap);
	return(retval);
}


/***********************************************************************************************
 * HouseClass::Silo_Redraw_Check -- Flags silos to be redrawn if necessary.                    *
 *                                                                                             *
 *    Call this routine when either the capacity or tiberium levels change for a house. This   *
 *    routine will determine if the aggregate tiberium storage level will result in the        *
 *    silos changing their imagery. If this is detected, then all the silos for this house     *
 *    are flagged to be redrawn.                                                               *
 *                                                                                             *
 * INPUT:   oldtib   -- Pre-change tiberium level.                                             *
 *                                                                                             *
 *          oldcap   -- Pre-change tiberium storage capacity.                                  *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/02/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Silo_Redraw_Check(long oldtib, long oldcap)
{
	assert(Houses.ID(this) == ID);

	int oldratio = 0;
	if (oldcap) oldratio = (oldtib * 5) / oldcap;
	int newratio = 0;
	if (Capacity) newratio = (Tiberium * 5) / Capacity;

	if (oldratio != newratio) {
		for (int index = 0; index < Buildings.Count(); index++) {
			BuildingClass * b = Buildings.Ptr(index);
			if (b && !b->IsInLimbo && b->House == this && *b == STRUCT_STORAGE) {
				b->Mark(MARK_CHANGE);
			}
		}
	}
}


/***********************************************************************************************
 * HouseClass::Is_Ally -- Determines if the specified house is an ally.                        *
 *                                                                                             *
 *    This routine will determine if the house number specified is a ally to this house.       *
 *                                                                                             *
 * INPUT:   house -- The house number to check to see if it is an ally.                        *
 *                                                                                             *
 * OUTPUT:  Is the house an ally?                                                              *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/08/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Is_Ally(HousesType house) const
{
	assert(Houses.ID(this) == ID);

	if (house != HOUSE_NONE) {
		return(((1<<house) & Allies) != 0);
	}
	return(false);
}


/***********************************************************************************************
 * HouseClass::Is_Ally -- Determines if the specified house is an ally.                        *
 *                                                                                             *
 *    This routine will examine the specified house and determine if it is an ally.            *
 *                                                                                             *
 * INPUT:   house -- Pointer to the house object to check for ally relationship.               *
 *                                                                                             *
 * OUTPUT:  Is the specified house an ally?                                                    *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/08/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Is_Ally(HouseClass const * house) const
{
	assert(Houses.ID(this) == ID);

	if (house) {
		return(Is_Ally(house->Class->House));
	}
	return(false);
}


/***********************************************************************************************
 * HouseClass::Is_Ally -- Checks to see if the object is an ally.                              *
 *                                                                                             *
 *    This routine will examine the specified object and return whether it is an ally or not.  *
 *                                                                                             *
 * INPUT:   object   -- The object to examine to see if it is an ally.                         *
 *                                                                                             *
 * OUTPUT:  Is the specified object an ally?                                                   *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/08/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Is_Ally(ObjectClass const * object) const
{
	assert(Houses.ID(this) == ID);

	if (object) {
		return(Is_Ally(object->Owner()));
	}
	return(false);
}


/***********************************************************************************************
 * HouseClass::Make_Ally -- Make the specified house an ally.                                  *
 *                                                                                             *
 *    This routine will make the specified house an ally to this house. An allied house will   *
 *    not be considered a threat or potential target.                                          *
 *                                                                                             *
 * INPUT:   house -- The house to make an ally of this house.                                  *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/08/1995 JLB : Created.                                                                 *
 *   08/08/1995 JLB : Breaks off combat when ally commences.                                   *
 *   10/17/1995 JLB : Added reveal base when allied.                                           *
 *=============================================================================================*/
void HouseClass::Make_Ally(HousesType house)
{
	assert(Houses.ID(this) == ID);

	if (Is_Allowed_To_Ally(house)) {

		Allies |= (1L << house);

		/*
		**	Don't consider the newfound ally to be an enemy -- of course.
		*/
		if (Enemy == house) {
			Enemy = HOUSE_NONE;
		}

		if (ScenarioInit) {
			Control.Allies |= (1L << house);
		}

		if (Session.Type != GAME_NORMAL && !ScenarioInit) {
			HouseClass * hptr = HouseClass::As_Pointer(house);

			/*
			**	An alliance with another human player will cause the computer
			**	players (if present) to become paranoid.
			*/
			if (hptr != NULL && IsHuman && Rule.IsComputerParanoid) {
//			if (hptr != NULL && hptr->IsHuman) {
//				if (!hptr->IsHuman) {
//					hptr->Make_Ally(Class->House);
//				}
				Computer_Paranoid();
			}

			char buffer[80];

			/*
			**	Sweep through all techno objects and perform a cheeseball tarcom clear to ensure
			**	that fighting will most likely stop when the cease fire begins.
			*/
			for (int index = 0; index < Logic.Count(); index++) {
				ObjectClass * object = Logic[index];

				if (object != NULL && object->Is_Techno() && !object->IsInLimbo && object->Owner() == Class->House) {
					TARGET target = ((TechnoClass *)object)->TarCom;
					if (Target_Legal(target) && As_Techno(target) != NULL) {
						if (Is_Ally(As_Techno(target))) {
							((TechnoClass *)object)->Assign_Target(TARGET_NONE);
						}
					}
				}
			}

			/*
			**	Cause all structures to be revealed to the house that has been
			**	allied with.
			*/
			if (Rule.IsAllyReveal && house == PlayerPtr->Class->House) {
				for (int index = 0; index < Buildings.Count(); index++) {
					BuildingClass const * b = Buildings.Ptr(index);

					if (b && !b->IsInLimbo && (HouseClass *)b->House == this) {
						Map.Sight_From(Coord_Cell(b->Center_Coord()), b->Class->SightRange, PlayerPtr, false);
					}
				}
			}

			if (IsHuman) {
				sprintf(buffer, Text_String(TXT_HAS_ALLIED), IniName, HouseClass::As_Pointer(house)->IniName);
//				sprintf(buffer, Text_String(TXT_HAS_ALLIED), Session.Players[Class->House - HOUSE_MULTI1]->Name, Session.Players[((HouseClass::As_Pointer(house))->Class->House) - HOUSE_MULTI1]->Name);
				Session.Messages.Add_Message(NULL, 0, buffer, RemapColor, TPF_6PT_GRAD|TPF_USE_GRAD_PAL|TPF_FULLSHADOW, TICKS_PER_MINUTE * Rule.MessageDelay);
			}

#if(TEN)
			//
			// Notify the TEN server of the new alliance
			//
			if (this == PlayerPtr && hptr != NULL && Session.Type == GAME_TEN) {
				Send_TEN_Alliance(hptr->IniName, 1);
			}
#endif	// TEN

#if(MPATH)
			//
			// Notify the MPATH server of the new alliance
			//
			//if (this == PlayerPtr && hptr != NULL && Session.Type == GAME_MPATH) {
				//Send_MPATH_Alliance(hptr->IniName, 1);
			//}
#endif	// MPATH

			Map.Flag_To_Redraw(false);
		}
	}
}


/***********************************************************************************************
 * HouseClass::Make_Enemy -- Make an enemy of the house specified.                             *
 *                                                                                             *
 *    This routine will flag the house specified so that it will be an enemy to this house.    *
 *    Enemy houses are legal targets for attack.                                               *
 *                                                                                             *
 * INPUT:   house -- The house to make an enemy of this house.                                 *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/08/1995 JLB : Created.                                                                 *
 *   07/27/1995 JLB : Making war is a bilateral action.                                        *
 *=============================================================================================*/
void HouseClass::Make_Enemy(HousesType house)
{
	assert(Houses.ID(this) == ID);

	if (house != HOUSE_NONE && Is_Ally(house)) {
		HouseClass * enemy = HouseClass::As_Pointer(house);
		Allies &= ~(1L << house);

		if (ScenarioInit) {
			Control.Allies &= !(1L << house);
		}

		/*
		**	Breaking an alliance is a bilateral event.
		*/
		if (enemy != NULL && enemy->Is_Ally(this)) {
			enemy->Allies &= ~(1L << Class->House);

			if (ScenarioInit) {
				Control.Allies &= ~(1L << Class->House);
			}
		}

		if ((Debug_Flag || Session.Type != GAME_NORMAL) && !ScenarioInit && IsHuman) {
			char buffer[80];

			sprintf(buffer, Text_String(TXT_AT_WAR), IniName, HouseClass::As_Pointer(house)->IniName);
//			sprintf(buffer, Text_String(TXT_AT_WAR), Session.Players[Class->House - HOUSE_MULTI1]->Name, Session.Players[enemy->Class->House - HOUSE_MULTI1]->Name);
			Session.Messages.Add_Message(NULL, 0, buffer, RemapColor, TPF_6PT_GRAD|TPF_USE_GRAD_PAL|TPF_FULLSHADOW, TICKS_PER_MINUTE * Rule.MessageDelay);
			Map.Flag_To_Redraw(false);

#if(TEN)
			//
			// Notify the TEN server of the broken alliance
			//
			if (this == PlayerPtr && enemy != NULL && Session.Type == GAME_TEN) {
				Send_TEN_Alliance(enemy->IniName, 0);
			}
#endif	// TEN

#if(MPATH)
			//
			// Notify the MPATH server of the broken alliance
			//
			//if (this == PlayerPtr && enemy != NULL && Session.Type == GAME_MPATH) {
				//Send_MPATH_Alliance(enemy->IniName, 0);
			//}
#endif	// MPATH

		}
	}
}


/***********************************************************************************************
 * HouseClass::Remap_Table -- Fetches the remap table for this house object.                   *
 *                                                                                             *
 *    This routine will return with the remap table to use when displaying an object owned     *
 *    by this house. If the object is blushing (flashing), then the lightening remap table is  *
 *    always used. The "unit" parameter allows proper remap selection for those houses that    *
 *    have a different remap table for buildings or units.                                     *
 *                                                                                             *
 * INPUT:   blushing -- Is the object blushing (flashing)?                                     *
 *                                                                                             *
 *          remap    -- The remap control value to use.                                        *
 *                      REMAP_NONE     No remap pointer returned at all.                       *
 *                      REMAP_NORMAL   Return the remap pointer for this house.                *
 *                      REMAP_ALTERNATE   (Nod solo play only -- forces red remap).            *
 *                                        Multiplay returns same as REMAP_NORMAL               *
 *                                                                                             *
 * OUTPUT:  Returns with a pointer to the remap table to use when drawing this object.         *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/08/1995 JLB : Created.                                                                 *
 *   10/25/1995 JLB : Uses remap control value.                                                *
 *=============================================================================================*/
unsigned char const * HouseClass::Remap_Table(bool blushing, RemapType remap) const
{
	assert(Houses.ID(this) == ID);

	if (blushing) return(&Map.FadingLight[0]);

	if (remap == REMAP_NONE) return(0);

	return(ColorRemaps[RemapColor].RemapTable);
}


/***********************************************************************************************
 * HouseClass::Suggested_New_Team -- Determine what team should be created.                    *
 *                                                                                             *
 *    This routine examines the house condition and returns with the team that it thinks       *
 *    should be created. The units that are not currently a member of a team are examined      *
 *    to determine the team needed.                                                            *
 *                                                                                             *
 * INPUT:   alertcheck  -- Select from the auto-create team list.                              *
 *                                                                                             *
 * OUTPUT:  Returns with a pointer to the team type that should be created. If no team should  *
 *          be created, then NULL is returned.                                                 *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/08/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
TeamTypeClass const * HouseClass::Suggested_New_Team(bool alertcheck)
{
	assert(Houses.ID(this) == ID);

	return(TeamTypeClass::Suggested_New_Team(this, AScan, UScan, IScan, VScan, alertcheck));
}


/***********************************************************************************************
 * HouseClass::Adjust_Threat -- Adjust threat for the region specified.                        *
 *                                                                                             *
 *    This routine is called when the threat rating for a region needs to change. The region   *
 *    and threat adjustment are provided.                                                      *
 *                                                                                             *
 * INPUT:   region   -- The region that adjustment is to occur on.                             *
 *                                                                                             *
 *          threat   -- The threat adjustment to perform.                                      *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/08/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Adjust_Threat(int region, int threat)
{
	assert(Houses.ID(this) == ID);

	static int _val[] = {
		-MAP_REGION_WIDTH - 1,	-MAP_REGION_WIDTH, -MAP_REGION_WIDTH + 1,
		-1,							0,						 1,
		MAP_REGION_WIDTH -1,		MAP_REGION_WIDTH,	 MAP_REGION_WIDTH +1
	};
	static int _thr[] = {
		2, 1, 2,
		1, 0, 1,
		2, 1,	2
	};
	int neg;
	int * val = &_val[0];
	int * thr = &_thr[0];

	if (threat < 0) {
		threat = -threat;
		neg = true;
	} else {
		neg = false;
	}

	for (int lp = 0; lp < 9; lp ++) {
		Regions[region + *val].Adjust_Threat(threat >> *thr, neg);
		val++;
		thr++;
	}
}


/***********************************************************************************************
 * HouseClass::Begin_Production -- Starts production of the specified object type.             *
 *                                                                                             *
 *    This routine is called from the event system. It will start production for the object    *
 *    type specified. This will be reflected in the sidebar as well as the house factory       *
 *    tracking variables.                                                                      *
 *                                                                                             *
 * INPUT:   type  -- The type of object to begin production on.                                *
 *                                                                                             *
 *          id    -- The subtype of object.                                                    *
 *                                                                                             *
 * OUTPUT:  Returns with the reason why, or why not, production was started.                   *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/08/1995 JLB : Created.                                                                 *
 *   10/21/1996 JLB : Handles max object case.                                                 *
 *=============================================================================================*/
ProdFailType HouseClass::Begin_Production(RTTIType type, int id)
{
	assert(Houses.ID(this) == ID);
	int result = true;
	bool initial_start = false;
	FactoryClass * fptr;
	TechnoTypeClass const * tech = Fetch_Techno_Type(type, id);

	fptr = Fetch_Factory(type);

	/*
	**	If the house is already busy producing the requested object, then
	**	return with this failure code, unless we are restarting production.
	*/
	if (fptr != NULL) {
		if (fptr->Is_Building()) {
			return(PROD_CANT);
		}
	} else {
		fptr = new FactoryClass();
		if (!fptr) return(PROD_CANT);
		Set_Factory(type, fptr);
		result = fptr->Set(*tech, *this);
		initial_start = true;
	}

	if (result) {
		fptr->Start();

		/*
		**	Link this factory to the sidebar so that proper graphic feedback
		**	can take place.
		*/
		if (PlayerPtr == this) {
			Map.Factory_Link(fptr->ID, type, id);
		}
		return(PROD_OK);
	}

	delete fptr;
	return(PROD_CANT);
}


/***********************************************************************************************
 * HouseClass::Suspend_Production -- Temporarily puts production on hold.                      *
 *                                                                                             *
 *    This routine is called from the event system whenever the production of the specified    *
 *    type needs to be suspended. The suspended production will be reflected in the sidebar    *
 *    as well as in the house control structure.                                               *
 *                                                                                             *
 * INPUT:   type  -- The type of object that production is being suspended for.                *
 *                                                                                             *
 * OUTPUT:  Returns why, or why not, production was suspended.                                 *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/08/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
ProdFailType HouseClass::Suspend_Production(RTTIType type)
{
	assert(Houses.ID(this) == ID);

	FactoryClass * fptr = Fetch_Factory(type);

	/*
	**	If the house is already busy producing the requested object, then
	**	return with this failure code.
	*/
	if (fptr == NULL) return(PROD_CANT);

	/*
	**	Actually suspend the production.
	*/
	fptr->Suspend();

	/*
	**	Tell the sidebar that it needs to be redrawn because of this.
	*/
	if (PlayerPtr == this) {
		Map.SidebarClass::IsToRedraw = true;
		Map.Flag_To_Redraw(false);
	}

	return(PROD_OK);
}


/***********************************************************************************************
 * HouseClass::Abandon_Production -- Abandons production of item type specified.               *
 *                                                                                             *
 *    This routine is called from the event system whenever production must be abandoned for   *
 *    the type specified. This will remove the factory and pending object from the sidebar as  *
 *    well as from the house factory record.                                                   *
 *                                                                                             *
 * INPUT:   type  -- The object type that production is being suspended for.                   *
 *                                                                                             *
 * OUTPUT:  Returns the reason why or why not, production was suspended.                       *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/08/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
ProdFailType HouseClass::Abandon_Production(RTTIType type)
{
	assert(Houses.ID(this) == ID);

	FactoryClass * fptr = Fetch_Factory(type);

	/*
	**	If there is no factory to abandon, then return with a failure code.
	*/
	if (fptr == NULL) return(PROD_CANT);

	/*
	**	Tell the sidebar that it needs to be redrawn because of this.
	*/
	if (PlayerPtr == this) {
		Map.Abandon_Production(type, fptr->ID);

		if (type == RTTI_BUILDINGTYPE || type == RTTI_BUILDING) {
			Map.PendingObjectPtr = 0;
			Map.PendingObject = 0;
			Map.PendingHouse = HOUSE_NONE;
			Map.Set_Cursor_Shape(0);
		}
	}

	/*
	**	Abandon production of the object.
	*/
	fptr->Abandon();
	Set_Factory(type, NULL);
	delete fptr;

	return(PROD_OK);
}


/***********************************************************************************************
 * HouseClass::Special_Weapon_AI -- Fires special weapon.                                      *
 *                                                                                             *
 *    This routine will pick a good target to fire the special weapon specified.               *
 *                                                                                             *
 * INPUT:   id -- The special weapon id to fire.                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   06/24/1995 PWG : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Special_Weapon_AI(SpecialWeaponType id)
{
	assert(Houses.ID(this) == ID);

	/*
	** Loop through all of the building objects on the map
	** and see which ones are available.
 	*/
	BuildingClass * bestptr = NULL;
	int best = -1;

	for (int index = 0; index < Buildings.Count(); index++) {
		BuildingClass * b = Buildings.Ptr(index);

		/*
		** If the building is valid, not in limbo, not in the process of
		** being destroyed and not our ally, then we can consider it.
		*/
		if (b != NULL && !b->IsInLimbo && b->Strength && !Is_Ally(b)) {
			if (Percent_Chance(90) && (b->Value() > best || best == -1)) {
				best = b->Value();
				bestptr = b;
			}
		}
	}

	if (bestptr) {
		CELL cell = Coord_Cell(bestptr->Center_Coord());
		Place_Special_Blast(id, cell);
	}
}


/***********************************************************************************************
 * HouseClass::Place_Special_Blast -- Place a special blast effect at location specified.      *
 *                                                                                             *
 *    This routine will create a blast effect at the cell specified. This is the result of     *
 *    the special weapons.                                                                     *
 *                                                                                             *
 * INPUT:   id    -- The special weapon id number.                                             *
 *                                                                                             *
 *          cell  -- The location where the special weapon attack is to occur.                 *
 *                                                                                             *
 * OUTPUT:  Was the special weapon successfully fired at the location specified?               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/18/1995 JLB : commented.                                                               *
 *   07/25/1995 JLB : Added scatter effect for nuclear bomb.                                   *
 *   07/28/1995 JLB : Revamped to use super weapon class controller.                           *
 *=============================================================================================*/
bool HouseClass::Place_Special_Blast(SpecialWeaponType id, CELL cell)
{
	assert(Houses.ID(this) == ID);

	BuildingClass * launchsite = 0;
	AnimClass * anim = 0;
	switch (id) {
		case SPC_SONAR_PULSE:
			// Automatically discharge the sonar pulse and uncloak all subs.
			if (SuperWeapon[SPC_SONAR_PULSE].Is_Ready()) {
				SuperWeapon[SPC_SONAR_PULSE].Discharged(this == PlayerPtr);
				if (this == PlayerPtr) {
					Map.Column[1].Flag_To_Redraw();
					Map.Activate_Pulse();
				}
				Sound_Effect(VOC_SONAR);
				IsRecalcNeeded = true;
				for (int index = 0; index < Vessels.Count(); index++) {
					VesselClass * sub = Vessels.Ptr(index);
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
					if (*sub == VESSEL_SS || *sub == VESSEL_MISSILESUB) {
#else
					if (*sub == VESSEL_SS) {
#endif
						sub->PulseCountDown = 15 * TICKS_PER_SECOND;
						sub->Do_Uncloak();
					}
				}
			}
			break;

		case SPC_NUCLEAR_BOMB:
			if (SuperWeapon[SPC_NUCLEAR_BOMB].Is_Ready()) {
				if (SuperWeapon[SPC_NUCLEAR_BOMB].Is_One_Time()) {
					BulletClass * bullet = new BulletClass(BULLET_NUKE_DOWN, ::As_Target(cell), 0, 200, WARHEAD_NUKE, MPH_VERY_FAST);
					if (bullet) {
						int celly = Cell_Y(cell);
						celly -= 15;
						if (celly < 1) celly = 1;
						COORDINATE start = Cell_Coord(XY_Cell(Cell_X(cell), celly));
						if (!bullet->Unlimbo(start, DIR_S)) {
							delete bullet;
						}
						SuperWeapon[SPC_NUCLEAR_BOMB].Discharged(this == PlayerPtr);
						IsRecalcNeeded = true;
						if (this == PlayerPtr) {
							Map.Column[1].Flag_To_Redraw();
							Map.IsTargettingMode = SPC_NONE;
						}
					}
				} else {

					/*
					**	Search for a suitable launch site for this missile.
					*/
					launchsite = Find_Building(STRUCT_MSLO);

					/*
					**	If a launch site was found, then proceed with the normal launch
					**	sequence.
					*/
					if (launchsite) {
						launchsite->Assign_Mission(MISSION_MISSILE);
						launchsite->Commence();
						NukeDest = cell;
					}
					if (this == PlayerPtr) {
						Map.IsTargettingMode = SPC_NONE;
					}
					SuperWeapon[SPC_NUCLEAR_BOMB].Discharged(this == PlayerPtr);
					IsRecalcNeeded = true;
				}
			}
			break;

		case SPC_PARA_INFANTRY:
			if (SuperWeapon[SPC_PARA_INFANTRY].Is_Ready()) {

				TeamTypeClass * ttype = TeamTypeClass::As_Pointer("@PINF");
				if (ttype == NULL) {
					ttype = new TeamTypeClass;
					if (ttype != NULL) {
						strcpy(ttype->IniName, "@PINF");
						ttype->IsTransient = true;
						ttype->IsPrebuilt = false;
						ttype->IsReinforcable = false;
						ttype->Origin = WAYPT_SPECIAL;
						ttype->MissionCount = 1;
						ttype->MissionList[0].Mission = TMISSION_ATT_WAYPT;
						ttype->MissionList[0].Data.Value = WAYPT_SPECIAL;
						ttype->ClassCount = 2;
						ttype->Members[0].Quantity = AircraftTypeClass::As_Reference(AIRCRAFT_BADGER).Max_Passengers();
						ttype->Members[0].Class = &InfantryTypeClass::As_Reference(INFANTRY_E1);
						ttype->Members[1].Quantity = 1;
						ttype->Members[1].Class = &AircraftTypeClass::As_Reference(AIRCRAFT_BADGER);
					}
				}

				if (ttype != NULL) {
					ttype->House = Class->House;
					Scen.Waypoint[WAYPT_SPECIAL] = Map.Nearby_Location(cell, SPEED_FOOT);
					Do_Reinforcements(ttype);
				}

//				Create_Air_Reinforcement(this, AIRCRAFT_BADGER, 1, MISSION_HUNT, ::As_Target(cell), TARGET_NONE, INFANTRY_E1);
				if (this == PlayerPtr) {
					Map.IsTargettingMode = SPC_NONE;
				}
				SuperWeapon[SPC_PARA_INFANTRY].Discharged(this == PlayerPtr);
				IsRecalcNeeded = true;
			}
			break;

		case SPC_SPY_MISSION:
			if (SuperWeapon[SPC_SPY_MISSION].Is_Ready()) {
				Create_Air_Reinforcement(this, AIRCRAFT_U2, 1, MISSION_HUNT, ::As_Target(cell), ::As_Target(cell));
				if (this == PlayerPtr) {
					Map.IsTargettingMode = SPC_NONE;
				}
				SuperWeapon[SPC_SPY_MISSION].Discharged(this == PlayerPtr);
				IsRecalcNeeded = true;
			}
			break;

		case SPC_PARA_BOMB:
			if (SuperWeapon[SPC_PARA_BOMB].Is_Ready()) {
				Create_Air_Reinforcement(this, AIRCRAFT_BADGER, Rule.BadgerBombCount, MISSION_HUNT, ::As_Target(cell), TARGET_NONE);
				if (this == PlayerPtr) {
					Map.IsTargettingMode = SPC_NONE;
				}
				SuperWeapon[SPC_PARA_BOMB].Discharged(this == PlayerPtr);
				IsRecalcNeeded = true;
			}
			break;

		case SPC_IRON_CURTAIN:
			if (SuperWeapon[SPC_IRON_CURTAIN].Is_Ready()) {
				int x = Keyboard->MouseQX - Map.TacPixelX;
				int y = Keyboard->MouseQY - Map.TacPixelY;
				TechnoClass * tech = Map[cell].Cell_Techno(x, y);
				if (tech) {
					switch (tech->What_Am_I()) {
						case RTTI_UNIT:
						case RTTI_BUILDING:
						case RTTI_VESSEL:
						case RTTI_AIRCRAFT:
							tech->IronCurtainCountDown = Rule.IronCurtainDuration * TICKS_PER_MINUTE;
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
							if (tech->What_Am_I() == RTTI_UNIT && *(UnitClass *)tech == UNIT_DEMOTRUCK) {
								tech->IronCurtainCountDown = Rule.IronCurtainDuration * TICKS_PER_SECOND;
							}
#endif
							tech->Mark(MARK_CHANGE);
							Sound_Effect(VOC_IRON1, tech->Center_Coord());
							if (this == PlayerPtr) {
								Map.IsTargettingMode = SPC_NONE;
							}
							SuperWeapon[SPC_IRON_CURTAIN].Discharged(this == PlayerPtr);
							break;
						default:
							break;
					}
				}

				IsRecalcNeeded = true;
			}
			break;

		case SPC_CHRONOSPHERE:
			if (SuperWeapon[SPC_CHRONOSPHERE].Is_Ready()) {
				int x = Keyboard->MouseQX - Map.TacPixelX;
				int y = Keyboard->MouseQY - Map.TacPixelY;
				TechnoClass * tech = Map[cell].Cell_Techno(x, y);
				if (tech && Is_Ally(tech)) {
					if (tech->What_Am_I() == RTTI_UNIT ||
						tech->What_Am_I() == RTTI_INFANTRY ||
#ifdef FIXIT_CARRIER	//	checked - ajw 9/28/98
						(tech->What_Am_I() == RTTI_VESSEL && (*((VesselClass *)tech) != VESSEL_TRANSPORT && *((VesselClass *)tech) != VESSEL_CARRIER) )) {
#else
						(tech->What_Am_I() == RTTI_VESSEL && *((VesselClass *)tech) != VESSEL_TRANSPORT)) {
#endif

						if (tech->What_Am_I() != RTTI_UNIT || !((UnitClass *)tech)->IsDeploying) {
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
	bool porthim = true;
	if(tech->What_Am_I() == RTTI_UNIT && ((UnitClass *)tech)->Class->Type == UNIT_CHRONOTANK) {
		porthim = false;
	}
	if (porthim) {
#endif
							if (this == PlayerPtr) {
								Map.IsTargettingMode = SPC_CHRONO2;
							}
							UnitToTeleport = tech->As_Target();
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
	}
#endif
						}
					}
				}
			}
			break;

		case SPC_CHRONO2:
			{
				TechnoClass * tech = (TechnoClass *)::As_Object(UnitToTeleport);
				CELL oldcell = cell;
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
				if (tech != NULL && tech->IsActive && tech->Is_Foot() && tech->What_Am_I() != RTTI_AIRCRAFT) {
#else
				if (tech != NULL && tech->Is_Foot() && tech->What_Am_I() != RTTI_AIRCRAFT) {
#endif
					/*
					** Destroy any infantryman that gets teleported
					*/
					if (tech->What_Am_I() == RTTI_INFANTRY) {
						InfantryClass * inf = (InfantryClass *)tech;
						inf->Mark(MARK_UP);
						inf->Coord = Cell_Coord(cell);
						inf->Mark(MARK_DOWN);
						int damage = inf->Strength;
						inf->Take_Damage(damage, 0, WARHEAD_FIRE, 0, true);
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
					} else if(tech->What_Am_I() == RTTI_UNIT && *(UnitClass *)tech == UNIT_DEMOTRUCK) {
						tech->Assign_Target(tech->As_Target());
#endif
					} else {
						/*
						**	Warp the unit to the new location.
						*/
						DriveClass * drive = (DriveClass *)tech;
						drive->MoebiusCell = Coord_Cell(drive->Coord);
						oldcell = drive->MoebiusCell;
						drive->Teleport_To(cell);
						drive->IsMoebius = true;
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
	if(tech->What_Am_I() == RTTI_UNIT && *(UnitClass *)tech == UNIT_CHRONOTANK) {
		drive->IsMoebius = false;
	}
	drive->MoebiusCountDown = Rule.ChronoDuration * TICKS_PER_MINUTE;
	if (tech->What_Am_I() == RTTI_UNIT && *(UnitClass *)tech == UNIT_CHRONOTANK) {
		drive->MoebiusCountDown = ChronoTankDuration * TICKS_PER_MINUTE;
	}
#else
						drive->MoebiusCountDown = Rule.ChronoDuration * TICKS_PER_MINUTE;
#endif
						Scen.Do_BW_Fade();
						Sound_Effect(VOC_CHRONO, drive->Coord);
					}
				}
				UnitToTeleport = TARGET_NONE;
				if (this == PlayerPtr) {
					Map.IsTargettingMode = SPC_NONE;
				}
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
	if(tech && tech->IsActive && (tech->What_Am_I() != RTTI_UNIT || *(UnitClass *)tech != UNIT_CHRONOTANK)) {
#endif
				SuperWeapon[SPC_CHRONOSPHERE].Discharged(this == PlayerPtr);
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
	}
#endif
				IsRecalcNeeded = true;

				/*
				** Now set a percentage chance that a time quake will occur.
				*/
				if (!TimeQuake) {
					TimeQuake = Percent_Chance(Rule.QuakeChance * 100);
				}

				/*
				** Now set a percentage chance that a chronal vortex will appear. It
				**	might appear where the object teleported to or it might appear
				**	where it teleported from -- random chance.
				*/
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
// Don't allow a vortex if the teleportation was due to a chrono tank.
	if(tech && tech->IsActive && (tech->What_Am_I() != RTTI_UNIT || *(UnitClass *)tech != UNIT_CHRONOTANK))
#endif
				if (!ChronalVortex.Is_Active() && Percent_Chance(Rule.VortexChance * 100)) {
					int x = Random_Pick(0, Map.MapCellWidth-1);
					int y = Random_Pick(0, Map.MapCellHeight-1);
					ChronalVortex.Appear(XY_Cell(Map.MapCellX + x, Map.MapCellY + y));

//					if (Percent_Chance(50)) {
//						ChronalVortex.Appear(Cell_Coord(oldcell));
//					} else {
//						ChronalVortex.Appear(Cell_Coord(cell));
//					}
				}

				break;
			}
	}
	return(true);
}


/***********************************************************************************************
 * HouseClass::Place_Object -- Places the object (building) at location specified.             *
 *                                                                                             *
 *    This routine is called when a building has been produced and now must be placed on       *
 *    the map. When the player clicks on the map, this routine is ultimately called when the   *
 *    event passes through the event queue system.                                             *
 *                                                                                             *
 * INPUT:   type  -- The object type to place. The actual object is lifted from the sidebar.   *
 *                                                                                             *
 *                                                                                             *
 *          cell  -- The location to place the object on the map.                              *
 *                                                                                             *
 * OUTPUT:  Was the placement successful?                                                      *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/18/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Place_Object(RTTIType type, CELL cell)
{
	assert(Houses.ID(this) == ID);

	TechnoClass * tech = 0;
	FactoryClass * factory = Fetch_Factory(type);

	/*
	**	Only if there is a factory active for this type, can it be "placed".
	**	In the case of a missing factory, then this request is completely bogus --
	**	ignore it. This might occur if, between two events to exit the same
	**	object, the mouse was clicked on the sidebar to start building again.
	**	The second placement event should NOT try to place the object that is
	**	just starting construction.
	*/
	if (factory && factory->Has_Completed()) {
		tech = factory->Get_Object();

		if (cell == -1) {
			TechnoClass * pending = factory->Get_Object();
			if (pending != NULL) {

#ifdef FIXIT_HELI_LANDING
				/*
				**	Try to find a place for the object to appear from. For helicopters, it has the
				**	option of finding a nearby helipad if no helipads are free.
				*/
				TechnoClass * builder = pending->Who_Can_Build_Me(false, false);
				if (builder == NULL && pending->What_Am_I() == RTTI_AIRCRAFT && !((AircraftClass *)pending)->Class->IsFixedWing) {
					builder = pending->Who_Can_Build_Me(true, false);

				}
#else
				bool intheory = false;
				if (pending->What_Am_I() == RTTI_AIRCRAFT) {

					/*
					** BG hack - helicopters don't need a specific building to
					** emerge from, in fact, they'll land next to a building if
					** need be.
					*/
					if( !((AircraftClass *)pending)->Class->IsFixedWing) {
						intheory = true;
					}
				}
				TechnoClass * builder = pending->Who_Can_Build_Me(intheory, false);
#endif

				if (builder != NULL && builder->Exit_Object(pending)) {

					/*
					**	Since the object has left the factory under its own power, delete
					**	the production manager tied to this slot in the sidebar. Its job
					**	has been completed.
					*/
					factory->Completed();
					Abandon_Production(type);
					switch (pending->What_Am_I()) {
						case RTTI_UNIT:
							JustBuiltUnit = ((UnitClass*)pending)->Class->Type;
							IsBuiltSomething = true;
							break;

						case RTTI_VESSEL:
							JustBuiltVessel = ((VesselClass*)pending)->Class->Type;
							IsBuiltSomething = true;
							break;

						case RTTI_INFANTRY:
							JustBuiltInfantry = ((InfantryClass*)pending)->Class->Type;
							IsBuiltSomething = true;
							break;

						case RTTI_BUILDING:
							JustBuiltStructure = ((BuildingClass*)pending)->Class->Type;
							IsBuiltSomething = true;
							break;

						case RTTI_AIRCRAFT:
							JustBuiltAircraft = ((AircraftClass*)pending)->Class->Type;
							IsBuiltSomething = true;
							break;
					}
				} else {
					/*
					**	The object could not leave under it's own power. Just wait
					**	until the player tries to place the object again.
					*/
					return(false);
				}
			}

		} else {
			if (tech) {
				TechnoClass * builder = tech->Who_Can_Build_Me(false, false);
				if (builder) {

					builder->Transmit_Message(RADIO_HELLO, tech);
					if (tech->Unlimbo(Cell_Coord(cell))) {
						factory->Completed();
						Abandon_Production(type);

						if (PlayerPtr == this) {
							Sound_Effect(VOC_PLACE_BUILDING_DOWN);
							Map.Set_Cursor_Shape(0);
							Map.PendingObjectPtr = 0;
							Map.PendingObject = 0;
							Map.PendingHouse = HOUSE_NONE;
						}
						return(true);
					} else {
						if (this == PlayerPtr) {
							Speak(VOX_DEPLOY);
						}
					}
					builder->Transmit_Message(RADIO_OVER_OUT);
				}
				return(false);

			} else {

				// Play a bad sound here?
				return(false);
			}
		}
	}

	return(true);
}


/***********************************************************************************************
 * HouseClass::Manual_Place -- Inform display system of building placement mode.               *
 *                                                                                             *
 *    This routine will inform the display system that building placement mode has begun.      *
 *    The cursor will be created that matches the layout of the building shape.                *
 *                                                                                             *
 * INPUT:   builder  -- The factory that is building this object.                              *
 *                                                                                             *
 *          object   -- The building that is going to be placed down on the map.               *
 *                                                                                             *
 * OUTPUT:  Was the building placement mode successfully initiated?                            *
 *                                                                                             *
 * WARNINGS:   This merely adjusts the cursor shape. Nothing that affects networked games      *
 *             is affected.                                                                    *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/04/1995 JLB : Created.                                                                 *
 *   05/30/1995 JLB : Uses the Bib_And_Offset() function to determine bib size.                *
 *=============================================================================================*/
bool HouseClass::Manual_Place(BuildingClass * builder,  BuildingClass * object)
{
	assert(Houses.ID(this) == ID);

	if (this == PlayerPtr && !Map.PendingObject && builder && object) {
		/*
		**	Ensures that object selection doesn't remain when
		**	building placement takes place.
		*/
		Unselect_All();

		Map.Repair_Mode_Control(0);
		Map.Sell_Mode_Control(0);

		Map.PendingObject = object->Class;
		Map.PendingObjectPtr = object;
		Map.PendingHouse = Class->House;

		Map.Set_Cursor_Shape(object->Occupy_List(true));
		Map.Set_Cursor_Pos(Coord_Cell(builder->Coord));
		builder->Mark(MARK_CHANGE);
		return(true);
	}
	return(false);
}


/***************************************************************************
 * HouseClass::Clobber_All -- removes all objects for this house				*
 *                                                                         *
 * INPUT:                                                                  *
 *      none.                                                              *
 *                                                                         *
 * OUTPUT:                                                                 *
 *      none.                                                              *
 *                                                                         *
 * WARNINGS:                                                               *
 *      This routine removes the house itself, so the multiplayer code		*
 *		  must not rely on there being "empty" houses lying around.				*
 *                                                                         *
 * HISTORY:                                                                *
 *   05/16/1995 BRR : Created.                                             *
 *   06/09/1995 JLB : Handles aircraft.                                    *
 *=========================================================================*/
void HouseClass::Clobber_All(void)
{
	assert(Houses.ID(this) == ID);

	int i;

	for (i = 0; i < ::Aircraft.Count(); i++) {
		if (::Aircraft.Ptr(i)->House == this) {
			delete ::Aircraft.Ptr(i);
			i--;
		}
	}
	for (i = 0; i < ::Units.Count(); i++) {
		if (::Units.Ptr(i)->House == this) {
			delete ::Units.Ptr(i);
			i--;
		}
	}
	for (i = 0; i < ::Vessels.Count(); i++) {
		if (::Vessels.Ptr(i)->House == this) {
			delete ::Vessels.Ptr(i);
			i--;
		}
	}
	for (i = 0; i < Infantry.Count(); i++) {
		if (Infantry.Ptr(i)->House == this) {
			delete Infantry.Ptr(i);
			i--;
		}
	}
	for (i = 0; i < Buildings.Count(); i++) {
		if (Buildings.Ptr(i)->House == this) {
			delete Buildings.Ptr(i);
			i--;
		}
	}
	for (i = 0; i < TeamTypes.Count(); i++) {
		if (TeamTypes.Ptr(i)->House == Class->House) {
			delete TeamTypes.Ptr(i);
			i--;
		}
	}
	for (i = 0; i < Triggers.Count(); i++) {
		if (Triggers.Ptr(i)->Class->House == Class->House) {
			delete Triggers.Ptr(i);
			i--;
		}
	}
	for (i = 0; i < TriggerTypes.Count(); i++) {
		if (TriggerTypes.Ptr(i)->House == Class->House) {
			delete TriggerTypes.Ptr(i);
			i--;
		}
	}

	delete this;
}


/***********************************************************************************************
 * HouseClass::Detach -- Removes specified object from house tracking systems.                 *
 *                                                                                             *
 *    This routine is called when an object is to be removed from the game system. If the      *
 *    specified object is part of the house tracking system, then it will be removed.          *
 *                                                                                             *
 * INPUT:   target   -- The target value of the object that is to be removed from the game.    *
 *                                                                                             *
 *          all      -- Is the target going away for good as opposed to just cloaking/hiding?  *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/18/1995 JLB : commented                                                                *
 *=============================================================================================*/
void HouseClass::Detach(TARGET target, bool )
{
	assert(Houses.ID(this) == ID);

	if (ToCapture == target) {
		ToCapture = TARGET_NONE;
	}

	if (Is_Target_Trigger(target)) {
		HouseTriggers[ID].Delete(As_Trigger(target));
	}
}


/***********************************************************************************************
 * HouseClass::Does_Enemy_Building_Exist -- Checks for enemy building of specified type.       *
 *                                                                                             *
 *    This routine will examine the enemy houses and if there is a building owned by one       *
 *    of those house, true will be returned.                                                   *
 *                                                                                             *
 * INPUT:   btype -- The building type to check for.                                           *
 *                                                                                             *
 * OUTPUT:  Does a building of the specified type exist for one of the enemy houses?           *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/23/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Does_Enemy_Building_Exist(StructType btype) const
{
	assert(Houses.ID(this) == ID);

	int bflag = 1L << btype;
	for (HousesType index = HOUSE_FIRST; index < HOUSE_COUNT; index++) {
		HouseClass * house = HouseClass::As_Pointer(index);

		if (house && !Is_Ally(house) && (house->ActiveBScan & bflag) != 0) {
			return(true);
		}
	}
	return(false);
}


/***********************************************************************************************
 * HouseClass::Suggest_New_Object -- Determine what would the next buildable object be.        *
 *                                                                                             *
 *    This routine will examine the house status and return with a techno type pointer to      *
 *    the object type that it thinks should be created. The type is restricted to match the    *
 *    type specified. Typical use of this routine is by computer controlled factories.         *
 *                                                                                             *
 * INPUT:   objecttype  -- The type of object to restrict the scan for.                        *
 *                                                                                             *
 *          kennel      -- Is this from a kennel? There are special hacks to ensure that only  *
 *                         dogs can be produced from a kennel.                                 *
 *                                                                                             *
 * OUTPUT:  Returns with a pointer to a techno type for the object type that should be         *
 *          created. If no object should be created, then NULL is returned.                    *
 *                                                                                             *
 * WARNINGS:   This is a time consuming routine. Only call when necessary.                     *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/23/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
TechnoTypeClass const * HouseClass::Suggest_New_Object(RTTIType objecttype, bool kennel) const
{
	assert(Houses.ID(this) == ID);

	TechnoTypeClass const * techno = NULL;

	switch (objecttype) {
		case RTTI_AIRCRAFT:
		case RTTI_AIRCRAFTTYPE:
			if (BuildAircraft != AIRCRAFT_NONE) {
				return(&AircraftTypeClass::As_Reference(BuildAircraft));
			}
			return(NULL);

		case RTTI_VESSEL:
		case RTTI_VESSELTYPE:
			if (BuildVessel != VESSEL_NONE) {
				return(&VesselTypeClass::As_Reference(BuildVessel));
			}
			return(NULL);

		/*
		**	Unit construction is based on the rule that up to twice the number required
		**	to fill all teams will be created.
		*/
		case RTTI_UNIT:
		case RTTI_UNITTYPE:
			if (BuildUnit != UNIT_NONE) {
				return(&UnitTypeClass::As_Reference(BuildUnit));
			}
			return(NULL);

		/*
		**	Infantry construction is based on the rule that up to twice the number required
		**	to fill all teams will be created.
		*/
		case RTTI_INFANTRY:
		case RTTI_INFANTRYTYPE:
			if (BuildInfantry != INFANTRY_NONE) {
				if (kennel && BuildInfantry != INFANTRY_DOG) return(NULL);
				if (!kennel && BuildInfantry == INFANTRY_DOG) return(NULL);
				return(&InfantryTypeClass::As_Reference(BuildInfantry));
			}
			return(NULL);

		/*
		**	Building construction is based upon the preconstruction list.
		*/
		case RTTI_BUILDING:
		case RTTI_BUILDINGTYPE:
			if (BuildStructure != STRUCT_NONE) {
				return(&BuildingTypeClass::As_Reference(BuildStructure));
			}
			return(NULL);
	}
	return(techno);
}


/***********************************************************************************************
 * HouseClass::Flag_Remove -- Removes the flag from the specified target.                      *
 *                                                                                             *
 *    This routine will remove the flag attached to the specified target object or cell.       *
 *    Call this routine before placing the object down. This is called inherently by the       *
 *    the Flag_Attach() functions.                                                             *
 *                                                                                             *
 * INPUT:   target   -- The target that the flag was attached to but will be removed from.     *
 *                                                                                             *
 *          set_home -- if true, clears the flag's waypoint designation                        *
 *                                                                                             *
 * OUTPUT:  Was the flag successfully removed from the specified target?                       *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/23/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Flag_Remove(TARGET target, bool set_home)
{
	assert(Houses.ID(this) == ID);

	int rc;

	if (Target_Legal(target)) {

		/*
		**	Remove the flag from a unit
		*/
		UnitClass * object = As_Unit(target);
		if (object) {
			rc = object->Flag_Remove();
			if (rc && FlagLocation == target) {
				FlagLocation = TARGET_NONE;
			}

		} else {

			/*
			**	Remove the flag from a cell
			*/
			CELL cell = As_Cell(target);
			if (Map.In_Radar(cell)) {
				rc = Map[cell].Flag_Remove();
				if (rc && FlagLocation == target) {
					FlagLocation = TARGET_NONE;
				}
			}
		}

		/*
		**	Handle the flag home cell:
		**	If 'set_home' is set, clear the home value & the cell's overlay
		*/
		if (set_home) {
			if (FlagHome != 0) {
				Map[FlagHome].Overlay = OVERLAY_NONE;
				Map.Flag_Cell(FlagHome);
				FlagHome = 0;
			}
		}

		return(rc);
	}
	return(false);
}


/***********************************************************************************************
 * HouseClass::Flag_Attach -- Attach flag to specified cell (or thereabouts).                  *
 *                                                                                             *
 *    This routine will attach the house flag to the location specified. If the location       *
 *    cannot contain the flag, then a suitable nearby location will be selected.               *
 *                                                                                             *
 * INPUT:   cell  -- The desired cell location to place the flag.                              *
 *                                                                                             *
 *          set_home -- if true, resets the flag's waypoint designation                        *
 *                                                                                             *
 * OUTPUT:  Was the flag successfully placed?                                                  *
 *                                                                                             *
 * WARNINGS:   The cell picked for the flag might very likely not be the cell requested.       *
 *             Check the FlagLocation value to determine the final cell resting spot.          *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/23/1995 JLB : Created.                                                                 *
 *   10/08/1996 JLB : Uses map nearby cell scanning handler.                                   *
 *=============================================================================================*/
bool HouseClass::Flag_Attach(CELL cell, bool set_home)
{
	assert(Houses.ID(this) == ID);

	bool rc;
	bool clockwise;

	/*
	**	Randomly decide if we're going to search cells clockwise or counter-
	**	clockwise
	*/
	clockwise = Percent_Chance(50);

	/*
	**	Only continue if this cell is a legal placement cell.
	*/
	if (Map.In_Radar(cell)) {

		/*
		**	If the flag already exists, then it must be removed from the object
		**	it is attached to.
		*/
		Flag_Remove(FlagLocation, set_home);

		/*
		**	Attach the flag to the cell specified. If it can't be placed, then pick
		**	a nearby cell where it can be placed.
		*/
		CELL newcell = cell;
		rc = Map[newcell].Flag_Place(Class->House);
		if (!rc) {
			newcell = Map.Nearby_Location(cell, SPEED_TRACK);
			if (newcell != 0) {
				rc = Map[newcell].Flag_Place(Class->House);
			}

#ifdef OBSOLETE
			/*
			**	Loop for increasing distance from the desired cell.
			**	For each distance, randomly pick a starting direction.  Between
			**	this and the clockwise/counterclockwise random value, the flag
			**	should appear to be placed fairly randomly.
			*/
			for (int dist = 1; dist < 32; dist++) {
				FacingType fcounter;
				FacingType rot;

				/*
				**	Clockwise search.
				*/
				if (clockwise) {
					rot = Random_Pick(FACING_N, FACING_NW);
					for (fcounter = FACING_N; fcounter <= FACING_NW; fcounter++) {
						newcell = Coord_Cell(Coord_Move(Cell_Coord(cell), Facing_Dir(rot), dist*256));
						if (Map.In_Radar(newcell) && Map[newcell].Flag_Place(Class->House)) {
							dist = 32;
							rc = true;
							break;
						}
						rot++;
						if (rot > FACING_NW) rot = FACING_N;
					}
				} else {

					/*
					**	Counter-clockwise search
					*/
					rot = Random_Pick(FACING_N, FACING_NW);
					for (fcounter = FACING_NW; fcounter >= FACING_N; fcounter--) {
						newcell = Coord_Cell(Coord_Move(Cell_Coord(cell), Facing_Dir(rot), dist*256));
						if (Map.In_Radar(newcell) && Map[newcell].Flag_Place(Class->House)) {
							dist = 32;
							rc = true;
							break;
						}
						rot--;
						if (rot < FACING_N)
							rot = FACING_NW;
					}
				}
			}
#endif
		}

		/*
		**	If we've found a spot for the flag, place the flag at the new cell.
		**	if 'set_home' is set, OR this house has no current flag home cell,
		**	mark that cell as this house's flag home cell.
		*/
		if (rc) {
			FlagLocation = As_Target(newcell);

			if (set_home || FlagHome == 0) {
				Map[newcell].Overlay = OVERLAY_FLAG_SPOT;
				Map[newcell].OverlayData = 0;
				Map[newcell].Recalc_Attributes();
				FlagHome = newcell;
			}
		}

		return(rc);
	}
	return(false);
}


/***********************************************************************************************
 * HouseClass::Flag_Attach -- Attaches the house flag the specified unit.                      *
 *                                                                                             *
 *    This routine will attach the house flag to the specified unit. This routine is called    *
 *    when a unit drives over a cell containing a flag.                                        *
 *                                                                                             *
 * INPUT:   object   -- Pointer to the object that the house flag is to be attached to.        *
 *                                                                                             *
 *          set_home -- if true, clears the flag's waypoint designation                        *
 *                                                                                             *
 * OUTPUT:  Was the flag attached successfully?                                                *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/23/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Flag_Attach(UnitClass * object, bool set_home)
{
	assert(Houses.ID(this) == ID);

	if (object && !object->IsInLimbo) {
		Flag_Remove(FlagLocation, set_home);

		/*
		**	Attach the flag to the object.
		*/
		object->Flag_Attach(Class->House);
		FlagLocation = object->As_Target();
		return(true);
	}
	return(false);
}


/***************************************************************************
 * HouseClass::MPlayer_Defeated -- multiplayer; house is defeated          *
 *                                                                         *
 * INPUT:                                                                  *
 *      none.                                                              *
 *                                                                         *
 * OUTPUT:                                                                 *
 *      none.                                                              *
 *                                                                         *
 * WARNINGS:                                                               *
 *      none.                                                              *
 *                                                                         *
 * HISTORY:                                                                *
 *   05/25/1995 BRR : Created.                                             *
 *=========================================================================*/
void HouseClass::MPlayer_Defeated(void)
{
	assert(Houses.ID(this) == ID);

	char txt[80];
	int i,j;
	unsigned char id;
	HouseClass * hptr;
	HouseClass * hptr2;
	int num_alive;
	int num_humans;
	int all_allies;

	/*
	**	Set the defeat flag for this house
	*/
	IsDefeated = true;

	/*
	**	If this is a computer controlled house, then all computer controlled
	**	houses become paranoid.
	*/
	if (IQ == Rule.MaxIQ && !IsHuman && Rule.IsComputerParanoid) {
		Computer_Paranoid();
	}

	/*
	**	Remove this house's flag & flag home cell
	*/
	if (Special.IsCaptureTheFlag) {
		if (FlagLocation) {
			Flag_Remove(FlagLocation, true);
		} else {
			if (FlagHome != 0) {
				Flag_Remove(FlagHome, true);
			}
		}
	}

	/*
	**	If this is me:
	**	- Set MPlayerObiWan, so I can only send messages to all players, and
	**	  not just one (so I can't be obnoxiously omnipotent)
	**	- Reveal the map
	**	- Add my defeat message
	*/
	if (PlayerPtr == this) {
		Session.ObiWan = 1;
		Debug_Unshroud = true;
		HidPage.Clear();
		Map.Flag_To_Redraw(true);

		/*
		**	Pop up a message showing that I was defeated
		*/
		sprintf(txt, Text_String(TXT_PLAYER_DEFEATED), IniName);
		Session.Messages.Add_Message(NULL, 0, txt, Session.ColorIdx,
			TPF_6PT_GRAD|TPF_USE_GRAD_PAL|TPF_FULLSHADOW, Rule.MessageDelay * TICKS_PER_MINUTE);
		Map.Flag_To_Redraw(false);

	} else {

		/*
		**	If it wasn't me, find out who was defeated
		*/
		if (IsHuman) {
			sprintf (txt, Text_String(TXT_PLAYER_DEFEATED), IniName);

			Session.Messages.Add_Message(NULL, 0, txt, RemapColor,
				TPF_6PT_GRAD | TPF_USE_GRAD_PAL | TPF_FULLSHADOW, Rule.MessageDelay * TICKS_PER_MINUTE);
			Map.Flag_To_Redraw(false);
			RedrawOptionsMenu = true;
		}
	}

	/*
	**	Find out how many players are left alive.
	*/
	num_alive = 0;
	num_humans = 0;
	for (i = 0; i < Session.MaxPlayers; i++) {
		hptr = HouseClass::As_Pointer((HousesType)(HOUSE_MULTI1 + i));
		if (hptr && !hptr->IsDefeated) {
			if (hptr->IsHuman) {
				num_humans++;
			}
			num_alive++;
		}
	}

	/*
	**	If all the houses left alive are allied with each other, then in reality
	**	there's only one player left:
	*/
	all_allies = 1;
	for (i = 0; i < Session.MaxPlayers; i++) {

		/*
		**	Get a pointer to this house
		*/
		hptr = HouseClass::As_Pointer((HousesType)(HOUSE_MULTI1 + i));
		if (!hptr || hptr->IsDefeated)
			continue;

		/*
		**	Loop through all houses; if there's one left alive that this house
		**	isn't allied with, then all_allies will be false
		*/
		for (j = 0; j < Session.MaxPlayers; j++) {
			hptr2 = HouseClass::As_Pointer((HousesType)(HOUSE_MULTI1 + j));
			if (!hptr2) {
				continue;
			}

			if (!hptr2->IsDefeated && !hptr->Is_Ally(hptr2)) {
				all_allies = 0;
				break;
			}
		}
		if (!all_allies) {
			break;
		}
	}

	/*
	**	If all houses left are allies, set 'num_alive' to 1; game over.
	*/
	if (all_allies) {
		num_alive = 1;
	}

	/*
	**	If there's only one human player left or no humans left, the game is over:
	**	- Determine whether this player wins or loses, based on the state of the
	**	  player's IsDefeated flag
	**	- Find all players' indices in the Session.Score array
	**	- Tally up scores for this game
	*/
	if (num_alive == 1 || num_humans == 0) {
		if (PlayerPtr->IsDefeated) {
			PlayerLoses = true;
		} else {
			PlayerWins = true;
		}

		/*
		** Add up the scores
		*/
		Tally_Score();

		/*
		**	Destroy all the IPX connections, since we have to go through the rest
		**	of the Main_Loop() before we detect that the game is over, and we'll
		**	end up waiting for frame sync packets from the other machines.
		*/
		if (Session.Type==GAME_IPX || Session.Type == GAME_INTERNET) {
			i = 0;
			while (Ipx.Num_Connections() && (i++ < 1000) ) {
				id = Ipx.Connection_ID(0);
				Ipx.Delete_Connection(id);
			}
			Session.NumPlayers = 0;
		}

#if(TEN)
		//
		// Tell the TEN server who won
		//
		if (Session.Type == GAME_TEN) {
			Send_TEN_Win_Packet();
		}
#endif	// TEN

#if(MPATH)
		//
		// Tell the MPATH server who won
		//
		if (Session.Type == GAME_MPATH) {
			FILE *fp;

			fp = fopen("winner.txt","wt");
			if (fp) {
				for (i = 0; i < Session.Players.Count(); i++) {
					hptr = HouseClass::As_Pointer(Session.Players[i]->Player.ID);
					if (!hptr->IsDefeated) {
						fprintf(fp,"%s\n",hptr->IniName);
					}
				}
				fclose(fp);
			}
		}
#endif	// MPATH

	}

	/*
	**	Be sure our messages get displayed, even if we're about to exit.
	*/
	Map.Render();
}


/***************************************************************************
 * HouseClass::Tally_Score -- Fills in the score system for this round     *
 *                                                                         *
 * INPUT:                                                                  *
 *		none.																						*
 *                                                                         *
 * OUTPUT:                                                                 *
 *		none.																						*
 *                                                                         *
 * WARNINGS:                                                               *
 *		none.																						*
 *                                                                         *
 * HISTORY:                                                                *
 *   11/29/1995 BRR : Created.                                             *
 *=========================================================================*/
void HouseClass::Tally_Score(void)
{
	HousesType house;
	HousesType house2;
	HouseClass * hptr;
	int score_index;
	int i,j,k;
	int max_index;
	int max_count;
	int count;

	/*
	** Loop through all houses, tallying up each player's score
	*/
	for (house = HOUSE_FIRST; house < HOUSE_COUNT; house++) {
		hptr = HouseClass::As_Pointer(house);
		/*
		** Skip this house if it's not human.
		*/
		if (!hptr || !hptr->IsHuman) {
			continue;
		}
		/*
		** Now find out where this player is in the score array
		*/
		score_index = -1;
		for (i = 0; i < Session.NumScores; i++) {
			if (!stricmp(hptr->IniName, Session.Score[i].Name)) {
				score_index = i;
				break;
			}
		}

		/*
		**	If the index is still -1, the name wasn't found; add a new entry.
		*/
		if (score_index == -1) {
			/*
			** Just add this player to the end of the array, if there's room
			*/
			if (Session.NumScores < MAX_MULTI_NAMES) {
				score_index = Session.NumScores;
				Session.NumScores++;
			}
			/*
			** If there's not room, we have to remove somebody.
			**	For each player in the scores array, count the # of '-1' entries
			**	from this game backwards; the one with the most is the one that
			**	hasn't played the longest; replace him with this new guy.
			*/
			else {
				max_index = 0;
				max_count = 0;
				for (j = 0; j < Session.NumScores; j++) {
					count = 0;
					for (k = Session.NumScores - 1; k >= 0; k--) {
						if (Session.Score[j].Kills[k]==-1) {
							count++;
						}
						else {
							break;
						}
					}
					if (count > max_count) {
						max_count = count;
						max_index = j;
					}
				}
				score_index = max_index;
			}

			/*
			**	Initialize this new score entry
			*/
			Session.Score[score_index].Wins = 0;
			strcpy (Session.Score[score_index].Name, hptr->IniName);
			for (j = 0; j < MAX_MULTI_GAMES; j++)
				Session.Score[score_index].Kills[j] = -1;
		}

		/*
		**	Init this player's Kills to 0 (-1 means he didn't play this round;
		**	0 means he played but got no kills).
		*/
		Session.Score[score_index].Kills[Session.CurGame] = 0;

		/*
		**	Init this player's color to his last-used color index
		*/
		Session.Score[score_index].Color = hptr->RemapColor;

		/*
		**	If this house was undefeated, it must have been the winner.
		** (If no human houses are undefeated, the computer won.)
		*/
		if (!hptr->IsDefeated) {
			Session.Score[score_index].Wins++;
			Session.Winner = score_index;
		}

		/*
		**	Tally up all kills for this player
		*/
		for (house2 = HOUSE_FIRST; house2 < HOUSE_COUNT; house2++) {
			Session.Score[score_index].Kills[Session.CurGame] += hptr->UnitsKilled[house2];
			Session.Score[score_index].Kills[Session.CurGame] += hptr->BuildingsKilled[house2];
		}
	}
}


/***************************************************************************
 * HouseClass::Blowup_All -- blows up everything                           *
 *                                                                         *
 * INPUT:                                                                  *
 *      none.                                                              *
 *                                                                         *
 * OUTPUT:                                                                 *
 *      none.                                                              *
 *                                                                         *
 * WARNINGS:                                                               *
 *      none.                                                              *
 *                                                                         *
 * HISTORY:                                                                *
 *   05/16/1995 BRR : Created.                                             *
 *   06/09/1995 JLB : Handles aircraft.                                    *
 *   05/07/1996 JLB : Handles ships.                                       *
 *=========================================================================*/
void HouseClass::Blowup_All(void)
{
	assert(Houses.ID(this) == ID);

	int i;
	int damage;
	UnitClass * uptr;
	InfantryClass * iptr;
	BuildingClass * bptr;
	int count;
	WarheadType warhead;

	/*
	**	Find everything owned by this house & blast it with a huge amount of damage
	**	at zero range.  Do units before infantry, so the units' drivers are killed
	**	too.  Using Explosion_Damage is like dropping a big bomb right on the
	**	object; it will also damage anything around it.
	*/
	for (i = 0; i < ::Units.Count(); i++) {
		if (::Units.Ptr(i)->House == this && !::Units.Ptr(i)->IsInLimbo) {
			uptr = ::Units.Ptr(i);

			/*
			**	Some units can't be killed with one shot, so keep damaging them until
			**	they're gone.  The unit will destroy itself, and put an infantry in
			**	its place.  When the unit destroys itself, decrement 'i' since
			**	its pointer will be removed from the active pointer list.
			*/
			count = 0;
			while (::Units.Ptr(i)==uptr && uptr->Strength) {
				damage = uptr->Strength;
				uptr->Take_Damage(damage, 0, WARHEAD_HE, NULL, true);
				count++;
				if (count > 5 && uptr->IsActive) {
					delete uptr;
					break;
				}
			}
			i--;
		}
	}

	/*
	**	Destroy all aircraft owned by this house.
	*/
	for (i = 0; i < ::Aircraft.Count(); i++) {
		if (::Aircraft.Ptr(i)->House == this && !::Aircraft.Ptr(i)->IsInLimbo) {
			AircraftClass * aptr = ::Aircraft.Ptr(i);

			damage = aptr->Strength;
			aptr->Take_Damage(damage, 0, WARHEAD_HE, NULL, true);
			if (!aptr->IsActive) {
				i--;
			}
		}
	}

	/*
	**	Destroy all vessels owned by this house.
	*/
	for (i = 0; i < ::Vessels.Count(); i++) {
		if (::Vessels.Ptr(i)->House == this && !::Vessels.Ptr(i)->IsInLimbo) {
			VesselClass * vptr = ::Vessels.Ptr(i);

			damage = vptr->Strength;
			vptr->Take_Damage(damage, 0, WARHEAD_HE, NULL, true);
			if (!vptr->IsActive) {
				i--;
			}
		}
	}

	/*
	**	Buildings don't delete themselves when they die; they shake the screen
	**	and begin a countdown, so don't decrement 'i' when it's destroyed.
	*/
	for (i = 0; i < Buildings.Count(); i++) {
		if (Buildings.Ptr(i)->House == this && !Buildings.Ptr(i)->IsInLimbo) {
			bptr = Buildings.Ptr(i);

			count = 0;
			while (Buildings.Ptr(i)==bptr && bptr->Strength) {
				damage = bptr->Strength;
				bptr->Take_Damage(damage, 0, WARHEAD_HE, NULL, true);
				count++;
				if (count > 5) {
					delete bptr;
					break;
				}
			}
		}
	}

	/*
	**	Infantry don't delete themselves when they die; they go into a death-
	**	animation sequence, so there's no need to decrement 'i' when they die.
	**	Infantry should die by different types of warheads, so their death
	**	anims aren't all synchronized.
	*/
	for (i = 0; i < Infantry.Count(); i++) {
		if (Infantry.Ptr(i)->House == this && !Infantry.Ptr(i)->IsInLimbo) {
			iptr = Infantry.Ptr(i);

			count = 0;
			while (Infantry.Ptr(i)==iptr && iptr->Strength) {
				damage = iptr->Strength;
				warhead = Random_Pick(WARHEAD_SA, WARHEAD_FIRE);
				iptr->Take_Damage(damage, 0, warhead, NULL, true);

				count++;
				if (count > 5) {
					delete iptr;
					break;
				}
			}
		}
	}
}


/***********************************************************************************************
 * HouseClass::Flag_To_Die -- Flags the house to blow up soon.                                 *
 *                                                                                             *
 *    When this routine is called, the house will blow up after a period of time. Typically    *
 *    this is called when the flag is captured or the HQ destroyed.                            *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Was the house flagged to blow up?                                                  *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   06/20/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Flag_To_Die(void)
{
	assert(Houses.ID(this) == ID);

	if (!IsToWin && !IsToDie && !IsToLose) {
		IsToDie = true;
		BorrowedTime = TICKS_PER_MINUTE * Rule.SavourDelay;
	}
	return(IsToDie);
}


/***********************************************************************************************
 * HouseClass::Flag_To_Win -- Flags the house to win soon.                                     *
 *                                                                                             *
 *    When this routine is called, the house will be declared the winner after a period of     *
 *    time.                                                                                    *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Was the house flagged to win?                                                      *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   06/20/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Flag_To_Win(void)
{
	assert(Houses.ID(this) == ID);

	if (!IsToWin && !IsToDie && !IsToLose) {
		IsToWin = true;
		BorrowedTime = TICKS_PER_MINUTE * Rule.SavourDelay;
	}
	return(IsToWin);
}


/***********************************************************************************************
 * HouseClass::Flag_To_Lose -- Flags the house to die soon.                                    *
 *                                                                                             *
 *    When this routine is called, it will spell the doom of this house. In a short while      *
 *    all of the object owned by this house will explode. Typical use of this routine is when  *
 *    the flag has been captured or the command vehicle has been destroyed.                    *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Has the doom been initiated?                                                       *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   06/12/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Flag_To_Lose(void)
{
	assert(Houses.ID(this) == ID);

	IsToWin = false;
	if (!IsToDie && !IsToLose) {
		IsToLose = true;
		BorrowedTime = TICKS_PER_MINUTE * Rule.SavourDelay;
	}
	return(IsToLose);
}


/***********************************************************************************************
 * HouseClass::Init_Data -- Initializes the multiplayer color data.                            *
 *                                                                                             *
 *    This routine is called when initializing the color and remap data for this house. The    *
 *    primary user of this routine is the multiplayer version of the game, especially for		  *
 *    saving & loading multiplayer games.																		  *
 *                                                                                             *
 * INPUT:   color    -- The color of this house.                                               *
 *                                                                                             *
 *          house    -- The house that this should act like.                                   *
 *                                                                                             *
 *          credits  -- The initial credits to assign to this house.                           *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/29/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Init_Data(PlayerColorType color, HousesType house, int credits)
{
	assert(Houses.ID(this) == ID);

	Credits = Control.InitialCredits = credits;
	RemapColor = color;
	ActLike = house;
}


/***********************************************************************************************
 * HouseClass::Power_Fraction -- Fetches the current power output rating.                      *
 *                                                                                             *
 *    Use this routine to fetch the current power output as a fixed point fraction. The        *
 *    value 0x0100 is 100% power.                                                              *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with power rating as a fixed pointer number.                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/22/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
fixed HouseClass::Power_Fraction(void) const
{
	assert(Houses.ID(this) == ID);

	if (Power >= Drain || Drain == 0) return(1);

	if (Power) {
		return(fixed(Power, Drain));
	}
	return(0);
}


/***********************************************************************************************
 * HouseClass::Sell_Wall -- Tries to sell the wall at the specified location.                  *
 *                                                                                             *
 *    This routine will try to sell the wall at the specified location. If there is a wall     *
 *    present and it is owned by this house, then it can be sold.                              *
 *                                                                                             *
 * INPUT:   cell  -- The cell that wall selling is desired.                                    *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   08/05/1995 JLB : Created.                                                                 *
 *   11/02/1996 JLB : Checks unsellable bit for wall type.                                     *
 *=============================================================================================*/
void HouseClass::Sell_Wall(CELL cell)
{
	assert(Houses.ID(this) == ID);

	if ((unsigned)cell > 0) {
		OverlayType overlay = Map[cell].Overlay;

		if (overlay != OVERLAY_NONE && Map[cell].Owner == Class->House) {
			OverlayTypeClass const & optr = OverlayTypeClass::As_Reference(overlay);

			if (optr.IsWall) {
				BuildingTypeClass const * btype = NULL;
				switch (overlay) {
					case OVERLAY_SANDBAG_WALL:
						btype = &BuildingTypeClass::As_Reference(STRUCT_SANDBAG_WALL);
						break;

					case OVERLAY_CYCLONE_WALL:
						btype = &BuildingTypeClass::As_Reference(STRUCT_CYCLONE_WALL);
						break;

					case OVERLAY_BRICK_WALL:
						btype = &BuildingTypeClass::As_Reference(STRUCT_BRICK_WALL);
						break;

					case OVERLAY_BARBWIRE_WALL:
						btype = &BuildingTypeClass::As_Reference(STRUCT_BARBWIRE_WALL);
						break;

					case OVERLAY_WOOD_WALL:
						btype = &BuildingTypeClass::As_Reference(STRUCT_WOOD_WALL);
						break;

					case OVERLAY_FENCE:
						btype = &BuildingTypeClass::As_Reference(STRUCT_FENCE);
						break;

					default:
						break;
				}
				if (btype != NULL && !btype->IsUnsellable) {

					if (PlayerPtr == this) {
						Sound_Effect(VOC_CASHTURN);
					}

					Refund_Money(btype->Raw_Cost() * Rule.RefundPercent);
					Map[cell].Overlay = OVERLAY_NONE;
					Map[cell].OverlayData = 0;
					Map[cell].Owner = HOUSE_NONE;
					Map[cell].Wall_Update();
					Map[cell].Recalc_Attributes();
					Map[cell].Redraw_Objects();
					Map.Radar_Pixel(cell);
					Detach_This_From_All(::As_Target(cell), true);

					if (optr.IsCrushable) {
						Map.Zone_Reset(MZONEF_NORMAL);
					} else {
						Map.Zone_Reset(MZONEF_CRUSHER|MZONEF_NORMAL);
					}
				}
			}
		}
	}
}


/***********************************************************************************************
 * HouseClass::Suggest_New_Building -- Examines the situation and suggests a building.         *
 *                                                                                             *
 *    This routine is called when a construction yard needs to know what to build next. It     *
 *    will either examine the prebuilt base list or try to figure out what to build next       *
 *    based on the current game situation.                                                     *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with a pointer to the building type class to build.                        *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/27/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
BuildingTypeClass const * HouseClass::Suggest_New_Building(void) const
{
	assert(Houses.ID(this) == ID);

	if (BuildStructure != STRUCT_NONE) {
		return(&BuildingTypeClass::As_Reference(BuildStructure));
	}
	return(NULL);
}


/***********************************************************************************************
 * HouseClass::Find_Building -- Finds a building of specified type.                            *
 *                                                                                             *
 *    This routine is used to find a building of the specified type. This is particularly      *
 *    useful for when some event requires a specific building instance. The nuclear missile    *
 *    launch is a good example.                                                                *
 *                                                                                             *
 * INPUT:   type  -- The building type to scan for.                                            *
 *                                                                                             *
 *          zone  -- The zone that the building must be located in. If no zone specific search *
 *                   is desired, then pass ZONE_NONE.                                          *
 *                                                                                             *
 * OUTPUT:  Returns with a pointer to the building type requested. If there is no building     *
 *          of the type requested, then NULL is returned.                                      *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/27/1995 JLB : Created.                                                                 *
 *   10/02/1995 JLB : Allows for zone specifics.                                               *
 *=============================================================================================*/
BuildingClass * HouseClass::Find_Building(StructType type, ZoneType zone) const
{
	assert(Houses.ID(this) == ID);

	/*
	**	Only scan if we KNOW there is at least one building of the type
	**	requested.
	*/
	if (BQuantity[type] > 0) {

		/*
		**	Search for a suitable launch site for this missile.
		*/
		for (int index = 0; index < Buildings.Count(); index++) {
			BuildingClass * b = Buildings.Ptr(index);
			if (b && !b->IsInLimbo && b->House == this && *b == type) {
				if (zone == ZONE_NONE || Which_Zone(b) == zone) {
					return(b);
				}
			}
		}
	}
	return(NULL);
}


/***********************************************************************************************
 * HouseClass::Find_Build_Location -- Finds a suitable building location.                      *
 *                                                                                             *
 *    This routine is used to find a suitable building location for the building specified.    *
 *    The auto base building logic uses this when building the base for the computer.          *
 *                                                                                             *
 * INPUT:   building -- Pointer to the building that needs to be placed down.                  *
 *                                                                                             *
 * OUTPUT:  Returns with the coordinate to place the building at. If there are no suitable     *
 *          locations, then NULL is returned.                                                  *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/27/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
COORDINATE HouseClass::Find_Build_Location(BuildingClass * building) const
{
	assert(Houses.ID(this) == ID);

	int zonerating[ZONE_COUNT];
	struct {
		int AntiAir;			// Average air defense for the base.
		int AntiArmor;			// Average armor defense for the base.
		int AntiInfantry;		// Average infantry defense for the base.
	} zoneinfo = {0,0,0};
	int antiair = building->Anti_Air();
	int antiarmor = building->Anti_Armor();
	int antiinfantry = building->Anti_Infantry();
	bool adj = true;

	/*
	**	Never place combat buildings adjacent to each other. This is partly
	**	because combat buildings don't have a bib and jamming will occur as well
	**	as because spacing defensive buildings out will yield a better
	**	defense.
	*/
	if (antiair || antiarmor || antiinfantry) {
		adj = false;
	}

	/*
	**	Determine the average zone strengths for the base. This value is
	**	used to determine what zones are considered under or over strength.
	*/
	for (ZoneType z = ZONE_NORTH; z < ZONE_COUNT; z++) {
		zoneinfo.AntiAir += ZoneInfo[z].AirDefense;
		zoneinfo.AntiArmor += ZoneInfo[z].ArmorDefense;
		zoneinfo.AntiInfantry += ZoneInfo[z].InfantryDefense;
	}
	zoneinfo.AntiAir /= ZONE_COUNT-ZONE_NORTH;
	zoneinfo.AntiArmor /= ZONE_COUNT-ZONE_NORTH;
	zoneinfo.AntiInfantry /= ZONE_COUNT-ZONE_NORTH;

	/*
	**	Give each zone a rating for value. The higher the value the more desirable
	**	to place the specified building in that zone. Factor the average value of
	**	zone defense such that more weight is given to zones that are very under
	**	defended.
	*/
	memset(&zonerating[0], '\0', sizeof(zonerating));
	for (z = ZONE_FIRST; z < ZONE_COUNT; z++) {
		int diff;

		diff = zoneinfo.AntiAir-ZoneInfo[z].AirDefense;
		if (z == ZONE_CORE) diff /= 2;
		if (diff > 0) {
			zonerating[z] += min(antiair, diff);
		}

		diff = zoneinfo.AntiArmor-ZoneInfo[z].ArmorDefense;
		if (z == ZONE_CORE) diff /= 2;
		if (diff > 0) {
			zonerating[z] += min(antiarmor, diff);
		}

		diff = zoneinfo.AntiInfantry-ZoneInfo[z].InfantryDefense;
		if (z == ZONE_CORE) diff /= 2;
		if (diff > 0) {
			zonerating[z] += min(antiinfantry, diff);
		}
	}

	/*
	**	Now that each zone has been given a desirability rating, find the zone
	**	with the greatest value and try to place the building in that zone.
	*/
	ZoneType zone = Random_Pick(ZONE_FIRST, ZONE_WEST);
	int largest = 0;
	for (z = ZONE_FIRST; z < ZONE_COUNT; z++) {
		if (zonerating[z] > largest) {
			zone = z;
			largest = zonerating[z];
		}
	}

	CELL zcell = Find_Cell_In_Zone(building, zone);
	if (zcell) {
		return(Cell_Coord(zcell));
	}

	/*
	**	Could not build in preferred zone, so try building in any zone.
	*/
	static ZoneType _zones[] = {ZONE_CORE, ZONE_NORTH, ZONE_SOUTH, ZONE_EAST, ZONE_WEST};
	int start = Random_Pick(0, ARRAY_SIZE(_zones)-1);
	for (int zz = 0; zz < ARRAY_SIZE(_zones); zz++) {
		ZoneType tryzone = _zones[(zz + start) % ARRAY_SIZE(_zones)];
		zcell = Find_Cell_In_Zone(building, tryzone);
		if (zcell) return(zcell);
	}

	return(NULL);
}


/***********************************************************************************************
 * HouseClass::Recalc_Center -- Recalculates the center point of the base.                     *
 *                                                                                             *
 *    This routine will average the location of the base and record the center point. The      *
 *    recorded center point is used to determine such things as how far the base is spread     *
 *    out and where to protect the most. This routine should be called whenever a building     *
 *    is created or destroyed.                                                                 *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/28/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Recalc_Center(void)
{
	assert(Houses.ID(this) == ID);

	/*
	**	First presume that there is no base. If there is a base, then these values will be
	**	properly filled in below.
	*/
	Center = 0;
	Radius = 0;
	for (ZoneType zone = ZONE_FIRST; zone < ZONE_COUNT; zone++) {
		ZoneInfo[zone].AirDefense = 0;
		ZoneInfo[zone].ArmorDefense = 0;
		ZoneInfo[zone].InfantryDefense = 0;
	}

	/*
	**	Only process the center base size/position calculation if there are buildings to
	**	consider. When no buildings for this house are present, then no processing need
	**	occur.
	*/
	if (CurBuildings > 0) {
		int x = 0;
		int y = 0;
		int count = 0;

		for (int index = 0; index < Buildings.Count(); index++) {
			BuildingClass const * b = Buildings.Ptr(index);

			if (b != NULL && !b->IsInLimbo && (HouseClass *)b->House == this && b->Strength > 0) {

				/*
				**	Give more "weight" to buildings that cost more. The presumption is that cheap
				**	buildings don't affect the base disposition as much as the more expensive
				**	buildings do.
				*/
				int weight = (b->Class->Cost_Of() / 1000)+1;
				for (int i = 0; i < weight; i++) {
					x += Coord_X(b->Center_Coord());
					y += Coord_Y(b->Center_Coord());
					count++;
				}
			}
		}

		/*
		**	This second check for quantity of buildings is necessary because the first
		**	check against CurBuildings doesn't take into account if the building is in
		**	limbo, but for base calculation, the limbo state disqualifies a building
		**	from being processed. Thus, CurBuildings may indicate a base, but count may
		**	not match.
		*/
		if (count > 0) {
			x /= count;
			y /= count;

#ifdef NEVER
			/*
			**	Bias the center of the base away from the edges of the map.
			*/
			LEPTON left = Cell_To_Lepton(Map.MapCellX + 10);
			LEPTON top = Cell_To_Lepton(Map.MapCellY + 10);
			LEPTON right = Cell_To_Lepton(Map.MapCellX + Map.MapCellWidth - 10);
			LEPTON bottom = Cell_To_Lepton(Map.MapCellY + Map.MapCellHeight - 10);
			if (x < left) x = left;
			if (x > right) x = right;
			if (y < top) y = top;
			if (y > bottom) y = bottom;
#endif

			Center = XY_Coord(x, y);
		}

		/*
		**	If there were any buildings discovered as legal to consider as part of the base,
		**	then figure out the general average radius of the building disposition as it
		**	relates to the center of the base.
		*/
		if (count > 1) {
			int radius = 0;

			for (index = 0; index < Buildings.Count(); index++) {
				BuildingClass const * b = Buildings.Ptr(index);

				if (b != NULL && !b->IsInLimbo && (HouseClass *)b->House == this && b->Strength > 0) {
					radius += Distance(Center, b->Center_Coord());
				}
			}
			Radius = max(radius / count, 2 * CELL_LEPTON_W);

			/*
			**	Determine the relative strength of each base defense zone.
			*/
			for (index = 0; index < Buildings.Count(); index++) {
				BuildingClass const * b = Buildings.Ptr(index);

				if (b != NULL && !b->IsInLimbo && (HouseClass *)b->House == this && b->Strength > 0) {
					ZoneType z = Which_Zone(b);

					if (z != ZONE_NONE) {
						ZoneInfo[z].ArmorDefense += b->Anti_Armor();
						ZoneInfo[z].AirDefense += b->Anti_Air();
						ZoneInfo[z].InfantryDefense += b->Anti_Infantry();
					}
				}
			}

		} else {
			Radius = 0x0200;
		}
	}
}


/***********************************************************************************************
 * HouseClass::Expert_AI -- Handles expert AI processing.                                      *
 *                                                                                             *
 *    This routine is called when the computer should perform expert AI processing. This       *
 *    method of AI is categorized as an "Expert System" process.                               *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns the number of game frames to delay before calling this routine again.      *
 *                                                                                             *
 * WARNINGS:   This is relatively time consuming -- call periodically.                         *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/29/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
int HouseClass::Expert_AI(void)
{
	assert(Houses.ID(this) == ID);

	BuildingClass * b = 0;
	bool stop = false;
	int time = TICKS_PER_SECOND * 10;

	/*
	**	If the current enemy no longer has a base or is defeated, then don't consider
	**	that house a threat anymore. Clear out the enemy record and then try
	**	to find a new enemy.
	*/
	if (Enemy != HOUSE_NONE) {
		HouseClass * h = HouseClass::As_Pointer(Enemy);

		if (h == NULL || !h->IsActive || h->IsDefeated || Is_Ally(h) || h->BScan == 0) {
			Enemy = HOUSE_NONE;
		}
	}

	/*
	**	If there is no enemy assigned to this house, then assign one now. The
	**	enemy that is closest is picked. However, don't pick an enemy if the
	**	base has not been established yet.
	*/
	if (ActiveBScan && Center && Attack == 0) {
		int close = 0;
		HousesType enemy = HOUSE_NONE;
		int maxunit = 0;
		int maxinfantry = 0;
		int maxvessel = 0;
		int maxaircraft = 0;
		int maxbuilding = 0;
		int enemycount = 0;

		for (HousesType house = HOUSE_FIRST; house < HOUSE_COUNT; house++) {
			HouseClass * h = HouseClass::As_Pointer(house);
			if (h != NULL && h->IsActive && !h->IsDefeated && !Is_Ally(h)) {

				/*
				**	Perform a special restriction check to ensure that no enemy is chosen if
				**	there is even one enemy that has not established a base yet. This will
				**	ensure an accurate first pick for enemy since the distance to base
				**	value can be determined.
				*/
				if (!h->IsStarted) {
					enemy = HOUSE_NONE;
					break;
				}

				/*
				**	Keep track of the number of buildings and units owned by the
				**	enemy. This is used to bring up the maximum allowed to match.
				*/
				maxunit += h->CurUnits;
				maxbuilding += h->CurBuildings;
				maxinfantry += h->CurInfantry;
				maxvessel += h->CurVessels;
				maxaircraft += h->CurAircraft;
				enemycount++;

				/*
				**	Determine a priority value based on distance to the center of the
				**	candidate base. The higher the value, the better the candidate house
				**	is to becoming the preferred enemy for this house.
				*/
				int value = ((MAP_CELL_W*2)-Distance(Center, h->Center));
				value *= 2;

				/*
				**	In addition to distance, record the number of kills directed
				**	against this house. The enemy that does more damage might be
				**	considered a greater threat.
				*/
				value += h->BuildingsKilled[Class->House]*5;
				value += h->UnitsKilled[Class->House];

				/*
				**	Factor in the relative sizes of the bases. An enemy that has a
				**	larger base will be considered a bigger threat. Conversely, a
				**	smaller base is considered a lesser threat.
				*/
				value += h->CurUnits - CurUnits;
				value += h->CurBuildings - CurBuildings;
				value += (h->CurInfantry - CurInfantry)/4;

				/*
				**	Whoever last attacked is given a little more priority as
				**	a potential designated enemy.
				*/
				if (house == LAEnemy) {
					value += 100;
				}

#ifdef OBSOLETE
				/*
				**	Human players are a given preference as the target.
				*/
				if (h->IsHuman) {
					value *= 2;
				}
#endif

				/*
				**	Compare the calculated value for this candidate house and if it is
				**	greater than the previously recorded maximum, record this house as
				**	the prime candidate for enemy.
				*/
				if (value > close) {
					enemy = house;
					close = value;
				}
			}
		}

		/*
		**	Record this closest enemy base as the first enemy to attack.
		*/
		Enemy = enemy;

		/*
		**	Up the maximum allowed units and buildings to match a rough average
		**	of what the enemies are allowed.
		*/
		if (enemycount) {
			maxunit /= enemycount;
			maxbuilding /= enemycount;
			maxinfantry /= enemycount;
			maxvessel /= enemycount;
			maxaircraft /= enemycount;
		}

		if (Control.MaxBuilding < maxbuilding + 10) {
			Control.MaxBuilding = maxbuilding + 10;
		}
		if (Control.MaxUnit < maxunit + 10) {
			Control.MaxUnit = maxunit + 10;
		}
		if (Control.MaxInfantry < maxinfantry + 10) {
			Control.MaxInfantry = maxinfantry + 10;
		}
		if (Control.MaxVessel < maxvessel + 10) {
			Control.MaxVessel = maxvessel + 10;
		}
		if (Control.MaxAircraft < maxaircraft + 10) {
			Control.MaxAircraft = maxaircraft + 10;
		}
	}

	/*
	**	House state transition check occurs here. Transitions that occur here are ones
	**	that relate to general base condition rather than specific combat events.
	**	Typically, this is limited to transitions between normal buildup mode and
	**	broke mode.
	*/
	if (State == STATE_ENDGAME) {
		Fire_Sale();
		Do_All_To_Hunt();
	} else {
		if (State == STATE_BUILDUP) {
			if (Available_Money() < 25) {
				State = STATE_BROKE;
			}
		}
		if (State == STATE_BROKE) {
			if (Available_Money() >= 25) {
				State = STATE_BUILDUP;
			}
		}
		if (State == STATE_ATTACKED && LATime + TICKS_PER_MINUTE < Frame) {
			State = STATE_BUILDUP;
		}
		if (State != STATE_ATTACKED && LATime + TICKS_PER_MINUTE > Frame) {
			State = STATE_ATTACKED;
		}
	}

	/*
	**	Records the urgency of all actions possible.
	*/
	UrgencyType urgency[STRATEGY_COUNT];

	for (StrategyType strat = STRATEGY_FIRST; strat < STRATEGY_COUNT; strat++) {
		urgency[strat] = URGENCY_NONE;

		switch (strat) {
			case STRATEGY_BUILD_POWER:
				urgency[strat] = Check_Build_Power();
				break;

			case STRATEGY_BUILD_DEFENSE:
				urgency[strat] = Check_Build_Defense();
				break;

			case STRATEGY_BUILD_INCOME:
				urgency[strat] = Check_Build_Income();
				break;

			case STRATEGY_FIRE_SALE:
				urgency[strat] = Check_Fire_Sale();
				break;

			case STRATEGY_BUILD_ENGINEER:
				urgency[strat] = Check_Build_Engineer();
				break;

			case STRATEGY_BUILD_OFFENSE:
				urgency[strat] = Check_Build_Offense();
				break;

			case STRATEGY_RAISE_MONEY:
				urgency[strat] = Check_Raise_Money();
				break;

			case STRATEGY_RAISE_POWER:
				urgency[strat] = Check_Raise_Power();
				break;

			case STRATEGY_LOWER_POWER:
				urgency[strat] = Check_Lower_Power();
				break;

			case STRATEGY_ATTACK:
				urgency[strat] = Check_Attack();
				break;

			default:
				urgency[strat] = URGENCY_NONE;
				break;
		}
	}

	/*
	**	Performs the action required for each of the strategies that share
	**	the most urgent category. Stop processing if any strategy at the
	**	highest urgency performed any action. This is because higher urgency
	**	actions tend to greatly affect the lower urgency actions.
	*/
	for (UrgencyType u = URGENCY_CRITICAL; u >= URGENCY_LOW; u--) {
		bool acted = false;

		for (strat = STRATEGY_FIRST; strat < STRATEGY_COUNT; strat++) {
			if (urgency[strat] == u) {
				switch (strat) {
					case STRATEGY_BUILD_POWER:
						acted |= AI_Build_Power(u);
						break;

					case STRATEGY_BUILD_DEFENSE:
						acted |= AI_Build_Defense(u);
						break;

					case STRATEGY_BUILD_INCOME:
						acted |= AI_Build_Income(u);
						break;

					case STRATEGY_FIRE_SALE:
						acted |= AI_Fire_Sale(u);
						break;

					case STRATEGY_BUILD_ENGINEER:
						acted |= AI_Build_Engineer(u);
						break;

					case STRATEGY_BUILD_OFFENSE:
						acted |= AI_Build_Offense(u);
						break;

					case STRATEGY_RAISE_MONEY:
						acted |= AI_Raise_Money(u);
						break;

					case STRATEGY_RAISE_POWER:
						acted |= AI_Raise_Power(u);
						break;

					case STRATEGY_LOWER_POWER:
						acted |= AI_Lower_Power(u);
						break;

					case STRATEGY_ATTACK:
						acted |= AI_Attack(u);
						break;

					default:
						break;
				}
			}
		}
	}

	return(TICKS_PER_SECOND*5 + Random_Pick(1, TICKS_PER_SECOND/2));
}


UrgencyType HouseClass::Check_Build_Power(void) const
{
	assert(Houses.ID(this) == ID);

	fixed frac = Power_Fraction();
	UrgencyType urgency = URGENCY_NONE;

	if (frac < 1 && Can_Make_Money()) {
		urgency = URGENCY_LOW;

		/*
		**	Very low power condition is considered a higher priority.
		*/
		if (frac < fixed::_3_4) urgency = URGENCY_MEDIUM;

		/*
		**	When under attack and there is a need for power in defense,
		**	then consider power building a higher priority.
		*/
		if (State == STATE_THREATENED || State == STATE_ATTACKED) {
			if (BScan | (STRUCTF_CHRONOSPHERE)) {
				urgency = URGENCY_HIGH;
			}
		}

	}
	return(urgency);
}


UrgencyType HouseClass::Check_Build_Defense(void) const
{
	assert(Houses.ID(this) == ID);

	/*
	**	This routine determines what urgency level that base defense
	**	should be given. The more vulnerable the base is, the higher
	**	the urgency this routine should return.
	*/
	return(URGENCY_NONE);
}


UrgencyType HouseClass::Check_Build_Offense(void) const
{
	assert(Houses.ID(this) == ID);

	/*
	**	This routine determines what urgency level that offensive
	**	weaponry should be given. Surplus money or a very strong
	**	defense will cause the offensive urgency to increase.
	*/
	return(URGENCY_NONE);
}

/*
**	Determines what the attack state of the base is. The higher the state,
**	the greater the immediate threat to base defense is.
*/
UrgencyType HouseClass::Check_Attack(void) const
{
	assert(Houses.ID(this) == ID);

	if (Frame > TICKS_PER_MINUTE && Attack == 0) {
		if (State == STATE_ATTACKED) {
			return(URGENCY_LOW);
		}
		return(URGENCY_CRITICAL);
	}
	return(URGENCY_NONE);
}


UrgencyType HouseClass::Check_Build_Income(void) const
{
	assert(Houses.ID(this) == ID);

	/*
	**	This routine should determine if income processing buildings
	**	should be constructed and at what urgency. The lower the money,
	**	the lower the refineries, or recent harvester losses should
	**	cause a greater urgency to be returned.
	*/
	return(URGENCY_NONE);
}


UrgencyType HouseClass::Check_Fire_Sale(void) const
{
	assert(Houses.ID(this) == ID);

	/*
	**	If there are no more factories at all, then sell everything off because the game
	**	is basically over at this point.
	*/
	if (State != STATE_ATTACKED && CurBuildings && !(ActiveBScan & (STRUCTF_TENT|STRUCTF_BARRACKS|STRUCTF_CONST|STRUCTF_AIRSTRIP|STRUCTF_WEAP|STRUCTF_HELIPAD))) {
		return(URGENCY_CRITICAL);
	}
	return(URGENCY_NONE);
}


UrgencyType HouseClass::Check_Build_Engineer(void) const
{
	assert(Houses.ID(this) == ID);

	/*
	**	This routine should check to see what urgency that the production of
	**	engineers should be. If a friendly building has been captured or the
	**	enemy has weak defenses, then building an engineer would be a priority.
	*/
	return(URGENCY_NONE);
}


/*
**	Checks to see if money is critically low and something must be done
**	to immediately raise cash.
*/
UrgencyType HouseClass::Check_Raise_Money(void) const
{
	assert(Houses.ID(this) == ID);

	UrgencyType urgency = URGENCY_NONE;
	if (Available_Money() < 100) {
		urgency = URGENCY_LOW;
	}
	if (Available_Money() < 2000 && !Can_Make_Money()) {
		urgency++;
	}

	return(urgency);
}

/*
**	Checks to see if power is very low and if so, a greater urgency to
**	build more power is returned.
*/
UrgencyType HouseClass::Check_Lower_Power(void) const
{
	assert(Houses.ID(this) == ID);

	if (Power > Drain+300) {
		return(URGENCY_LOW);
	}
	return(URGENCY_NONE);
}

/*
**	This routine determines if there is a power emergency. Such an
**	emergency might require selling of structures in order to free
**	up power. This might occur if the base is being attacked and there
**	are defenses that require power, but are just short of having
**	enough.
*/
UrgencyType HouseClass::Check_Raise_Power(void) const
{
	assert(Houses.ID(this) == ID);

	UrgencyType urgency = URGENCY_NONE;

	if (Power_Fraction() < Rule.PowerEmergencyFraction && Power < Drain - 400) {
//	if (Power_Fraction() < Rule.PowerEmergencyFraction && (BQuantity[STRUCT_CONST] == 0 || Available_Money() < 200 || Power < Drain-400)) {
		urgency = URGENCY_MEDIUM;
		if (State == STATE_ATTACKED) {
			urgency++;
		}
	}
	return(urgency);
}


bool HouseClass::AI_Attack(UrgencyType )
{
	assert(Houses.ID(this) == ID);

	bool shuffle = !((Frame > TICKS_PER_MINUTE && !CurBuildings) || Percent_Chance(33));
	bool forced = (CurBuildings == 0);
	int index;
	for (index = 0; index < Aircraft.Count(); index++) {
		AircraftClass * a = Aircraft.Ptr(index);

		if (a != NULL && !a->IsInLimbo && a->House == this && a->Strength > 0) {
			if (!shuffle && a->Is_Weapon_Equipped() && (forced || Percent_Chance(75))) {
				a->Assign_Mission(MISSION_HUNT);
			}
		}
	}
	for (index = 0; index < Units.Count(); index++) {
		UnitClass * u = Units.Ptr(index);

		if (u != NULL && !u->IsInLimbo && u->House == this && u->Strength > 0) {
			if (!shuffle && u->Is_Weapon_Equipped() && (forced || Percent_Chance(75))) {
				u->Assign_Mission(MISSION_HUNT);
			} else {

				/*
				**	If this unit is guarding the base, then cause it to shuffle
				**	location instead.
				*/
				if (Percent_Chance(20) && u->Mission == MISSION_GUARD_AREA && Which_Zone(u) != ZONE_NONE) {
					u->ArchiveTarget = ::As_Target(Where_To_Go(u));
				}
			}
		}
	}
	for (index = 0; index < Infantry.Count(); index++) {
		InfantryClass * i = Infantry.Ptr(index);

		if (i != NULL && !i->IsInLimbo && i->House == this && i->Strength > 0) {
			if (!shuffle && (i->Is_Weapon_Equipped() || *i == INFANTRY_RENOVATOR) && (forced || Percent_Chance(75))) {
				i->Assign_Mission(MISSION_HUNT);
			} else {

				/*
				**	If this soldier is guarding the base, then cause it to shuffle
				**	location instead.
				*/
				if (Percent_Chance(20) && i->Mission == MISSION_GUARD_AREA && Which_Zone(i) != ZONE_NONE) {
					i->ArchiveTarget = ::As_Target(Where_To_Go(i));
				}
			}
		}
	}
	Attack = Rule.AttackInterval * Random_Pick(TICKS_PER_MINUTE/2, TICKS_PER_MINUTE*2);
	return(true);
}


/*
**	Given the specified urgency, build a power structure to meet
**	this need.
*/
bool HouseClass::AI_Build_Power(UrgencyType ) const
{
	assert(Houses.ID(this) == ID);

	return(false);
}


/*
**	Given the specified urgency, build base defensive structures
**	according to need and according to existing base disposition.
*/
bool HouseClass::AI_Build_Defense(UrgencyType ) const
{
	assert(Houses.ID(this) == ID);

	return(false);
}

/*
**	Given the specified urgency, build offensive units according
**	to need and according to the opponents base defenses.
*/
bool HouseClass::AI_Build_Offense(UrgencyType ) const
{
	assert(Houses.ID(this) == ID);

	return(false);
}

/*
**	Given the specified urgency, build income producing
**	structures according to need.
*/
bool HouseClass::AI_Build_Income(UrgencyType ) const
{
	assert(Houses.ID(this) == ID);

	return(false);
}


bool HouseClass::AI_Fire_Sale(UrgencyType urgency)
{
	assert(Houses.ID(this) == ID);

	if (CurBuildings && urgency == URGENCY_CRITICAL) {
		Fire_Sale();
		Do_All_To_Hunt();
		return(true);
	}
	return(false);
}

/*
**	Given the specified urgency, build an engineer.
*/
bool HouseClass::AI_Build_Engineer(UrgencyType ) const
{
	assert(Houses.ID(this) == ID);

	return(false);
}

/*
**	Given the specified urgency, sell of some power since
**	there appears to be excess.
*/
bool HouseClass::AI_Lower_Power(UrgencyType ) const
{
	assert(Houses.ID(this) == ID);

	BuildingClass * b = Find_Building(STRUCT_POWER);
	if (b != NULL) {
		b->Sell_Back(1);
		return(true);
	}

	b = Find_Building(STRUCT_ADVANCED_POWER);
	if (b != NULL) {
		b->Sell_Back(1);
		return(true);
	}
	return(false);
}


/***********************************************************************************************
 * HouseClass::AI_Raise_Power -- Try to raise power levels by selling off buildings.           *
 *                                                                                             *
 *    This routine is called when the computer needs to raise power by selling off buildings.  *
 *    Usually this occurs because of some catastrophe that has lowered power levels to         *
 *    the danger zone.                                                                         *
 *                                                                                             *
 * INPUT:   urgency  -- The urgency that the power needs to be raised. This controls what      *
 *                      buildings will be sold.                                                *
 *                                                                                             *
 * OUTPUT:  bool; Was a building sold to raise power?                                          *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   11/02/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::AI_Raise_Power(UrgencyType urgency) const
{
	assert(Houses.ID(this) == ID);

	/*
	**	Sell off structures in this order.
	*/
	static struct {
		StructType Structure;
		UrgencyType Urgency;
	} _types[] = {
		{STRUCT_CHRONOSPHERE, URGENCY_LOW},
		{STRUCT_SHIP_YARD, URGENCY_LOW},
		{STRUCT_SUB_PEN, URGENCY_LOW},
		{STRUCT_ADVANCED_TECH, URGENCY_LOW},
		{STRUCT_FORWARD_COM, URGENCY_LOW},
		{STRUCT_SOVIET_TECH, URGENCY_LOW},
		{STRUCT_IRON_CURTAIN, URGENCY_MEDIUM},
		{STRUCT_RADAR, URGENCY_MEDIUM},
		{STRUCT_REPAIR, URGENCY_MEDIUM},
		{STRUCT_TESLA, URGENCY_HIGH}
	};

	/*
	**	Find a structure to sell and then sell it. Bail from further scanning until
	**	the next time.
	*/
	for (int i = 0; i < ARRAY_SIZE(_types); i++) {
		if (urgency >= _types[i].Urgency) {
			BuildingClass * b = Find_Building(_types[i].Structure);
			if (b != NULL) {
				b->Sell_Back(1);
				return(true);
			}
		}
	}
	return(false);
}


/***********************************************************************************************
 * HouseClass::AI_Raise_Money -- Raise emergency cash by selling buildings.                    *
 *                                                                                             *
 *    This routine handles the situation where the computer desperately needs cash but cannot  *
 *    wait for normal harvesting to raise it. Buildings must be sold.                          *
 *                                                                                             *
 * INPUT:   urgency  -- The urgency level that cash must be raised. The greater the urgency,   *
 *                      the more important the buildings that can be sold become.              *
 *                                                                                             *
 * OUTPUT:  bool; Was a building sold to raise cash?                                           *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   11/02/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::AI_Raise_Money(UrgencyType urgency) const
{
	assert(Houses.ID(this) == ID);

	/*
	**	Sell off structures in this order.
	*/
	static struct {
		StructType	Structure;
		UrgencyType	Urgency;
	} _types[] = {
		{STRUCT_CHRONOSPHERE, URGENCY_LOW},
		{STRUCT_SHIP_YARD, URGENCY_LOW},
		{STRUCT_SUB_PEN, URGENCY_LOW},
		{STRUCT_ADVANCED_TECH, URGENCY_LOW},
		{STRUCT_FORWARD_COM, URGENCY_LOW},
		{STRUCT_SOVIET_TECH, URGENCY_LOW},
		{STRUCT_STORAGE,URGENCY_LOW},
		{STRUCT_REPAIR,URGENCY_LOW},
		{STRUCT_TESLA,URGENCY_MEDIUM},
		{STRUCT_HELIPAD,URGENCY_MEDIUM},
		{STRUCT_POWER,URGENCY_HIGH},
		{STRUCT_AIRSTRIP,URGENCY_HIGH},
//		{STRUCT_WEAP,URGENCY_HIGH},
//		{STRUCT_BARRACKS,URGENCY_HIGH},
//		{STRUCT_TENT,URGENCY_HIGH},
		{STRUCT_CONST,URGENCY_CRITICAL}
	};
	BuildingClass * b = 0;

	/*
	**	Find a structure to sell and then sell it. Bail from further scanning until
	**	the next time.
	*/
	for (int i = 0; i < ARRAY_SIZE(_types); i++) {
		if (urgency >= _types[i].Urgency) {
			b = Find_Building(_types[i].Structure);
			if (b != NULL) {
				b->Sell_Back(1);
				return(true);
			}
		}
	}
	return(false);
}


#ifdef NEVER

/***********************************************************************************************
 * HouseClass::AI_Base_Defense -- Handles maintaining a strong base defense.                   *
 *                                                                                             *
 *    This logic is used to maintain a base defense.                                           *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the number of game frames to delay before calling this routine again. *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/29/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
int HouseClass::AI_Base_Defense(void)
{
	assert(Houses.ID(this) == ID);

	/*
	**	Check to find if any zone of the base is over defended. Such zones should have
	**	some of their defenses sold off to make better use of the money.
	*/

	/*
	**	Make sure that the core defense is only about 1/2 of the perimeter defense average.
	*/
	int average = 0;
	for (ZoneType z = ZONE_NORTH; z < ZONE_COUNT; z++) {
		average += ZoneInfo[z].AirDefense;
		average += ZoneInfo[z].ArmorDefense;
		average += ZoneInfo[z].InfantryDefense;
	}
	average /= (ZONE_COUNT-ZONE_NORTH);

	/*
	**	If the core value is greater than the average, then sell off some of the
	**	inner defensive structures.
	*/
	int core = ZoneInfo[ZONE_CORE].AirDefense + ZoneInfo[ZONE_CORE].ArmorDefense + ZoneInfo[ZONE_CORE].InfantryDefense;
	if (core >= average) {
		static StructType _stype[] = {
			STRUCT_GTOWER,
			STRUCT_TURRET,
			STRUCT_ATOWER,
			STRUCT_OBELISK,
			STRUCT_TESLA,
			STRUCT_SAM
		};
		BuildingClass * b;

		for (int index = 0; index < sizeof(_stype)/sizeof(_stype[0]); index++) {
			b = Find_Building(_stype[index], ZONE_CORE);
			if (b) {
				b->Sell_Back(1);
				break;
			}
		}
	}

	/*
	**	If the enemy doesn't have any offensive air capability, then sell off any
	**	SAM sites. Only do this when money is moderately low.
	*/
	if (Available_Money() < 1000 && (ActiveBScan & STRUCTF_SAM)) {

		/*
		**	Scan to find if ANY human opponents have aircraft or a helipad. If one
		** is found then consider that opponent to have a valid air threat potential.
		**	Don't sell off SAM sites in that case.
		*/
		bool nothreat = true;
		for (HousesType h = HOUSE_FIRST; h < HOUSE_COUNT; h++) {
			HouseClass * house = HouseClass::As_Pointer(h);

			if (house && house->IsActive && house->IsHuman && !Is_Ally(house)) {
				if ((house->ActiveAScan & (AIRCRAFTF_ORCA|AIRCRAFTF_TRANSPORT|AIRCRAFTF_HELICOPTER)) || (house->ActiveBScan & STRUCTF_HELIPAD)) {
					nothreat = false;
					break;
				}
			}
		}
	}

	return(TICKS_PER_SECOND*5);
}
#endif


/***********************************************************************************************
 * HouseClass::AI_Building -- Determines what building to build.                               *
 *                                                                                             *
 *    This routine handles the general case of determining what building to build next.        *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the number of game frames to delay before calling this routine again. *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/29/1995 JLB : Created.                                                                 *
 *   11/03/1996 JLB : Tries to match aircraft of enemy                                         *
 *=============================================================================================*/
int HouseClass::AI_Building(void)
{
	assert(Houses.ID(this) == ID);

	if (BuildStructure != STRUCT_NONE) return(TICKS_PER_SECOND);

	if (Session.Type == GAME_NORMAL && Base.House == Class->House) {
		BaseNodeClass * node = Base.Next_Buildable();
		if (node) {
			BuildStructure = node->Type;
		}
	}

	if (IsBaseBuilding) {
		/*
		**	Don't suggest anything to build if the base is already big enough.
		*/
		int quant = 0;
		for (HousesType h = HOUSE_FIRST; h < HOUSE_COUNT; h++) {
			HouseClass const * hptr = HouseClass::As_Pointer(h);

			if (hptr != NULL && hptr->IsActive && hptr->IsHuman && quant < hptr->CurBuildings) {
				quant = hptr->CurBuildings;
			}
		}
		quant += Rule.BaseSizeAdd;

// TCTC -- Should multiply largest player base by some rational number.
//		if (CurBuildings >= quant) return(TICKS_PER_SECOND);

		BuildChoice.Free_All();
		BuildChoiceClass * choiceptr;
		StructType stype = STRUCT_NONE;
		int money = Available_Money();
		int level = Control.TechLevel;
		bool hasincome = (BQuantity[STRUCT_REFINERY] > 0 && !IsTiberiumShort && UQuantity[UNIT_HARVESTER] > 0);
		BuildingTypeClass const * b = NULL;
		HouseClass const * enemy = NULL;
		if (Enemy != HOUSE_NONE) {
			enemy = HouseClass::As_Pointer(Enemy);
		}

		level = Control.TechLevel;

		/*
		**	Try to build a power plant if there is insufficient power and there is enough
		**	money available.
		*/
		b = &BuildingTypeClass::As_Reference(STRUCT_ADVANCED_POWER);
		if (Can_Build(b, ActLike) && Power <= Drain+Rule.PowerSurplus && b->Cost_Of() < money) {
			choiceptr = BuildChoice.Alloc();
			if (choiceptr != NULL) {
				*choiceptr = BuildChoiceClass(BQuantity[STRUCT_REFINERY] == 0 ? URGENCY_LOW : URGENCY_MEDIUM, b->Type);
			}
		} else {
			b = &BuildingTypeClass::As_Reference(STRUCT_POWER);
			if (Can_Build(b, ActLike) && Power <= Drain+Rule.PowerSurplus && b->Cost_Of() < money) {
				choiceptr = BuildChoice.Alloc();
				if (choiceptr != NULL) {
					*choiceptr = BuildChoiceClass(BQuantity[STRUCT_REFINERY] == 0 ? URGENCY_LOW : URGENCY_MEDIUM, b->Type);
				}
			}
		}

		/*
		**	Build a refinery if there isn't one already available.
		*/
		unsigned int current = BQuantity[STRUCT_REFINERY];
		if (!IsTiberiumShort && current < Round_Up(Rule.RefineryRatio*fixed(CurBuildings)) && current < Rule.RefineryLimit) {
			b = &BuildingTypeClass::As_Reference(STRUCT_REFINERY);
			if (Can_Build(b, ActLike) && (money > b->Cost_Of() || hasincome)) {
				choiceptr = BuildChoice.Alloc();
				if (choiceptr != NULL) {
					*choiceptr = BuildChoiceClass(BQuantity[STRUCT_REFINERY] == 0 ? URGENCY_HIGH : URGENCY_MEDIUM, b->Type);
				}
			}
		}

		/*
		**	Always make sure there is a barracks available, but only if there
		**	will be sufficient money to train troopers.
		*/
		current = BQuantity[STRUCT_BARRACKS] + BQuantity[STRUCT_TENT];
		if (current < Round_Up(Rule.BarracksRatio*fixed(CurBuildings)) && current < Rule.BarracksLimit && (money > 300 || hasincome)) {
			b = &BuildingTypeClass::As_Reference(STRUCT_BARRACKS);
			if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
				choiceptr = BuildChoice.Alloc();
				if (choiceptr != NULL) {
					*choiceptr = BuildChoiceClass(current > 0 ? URGENCY_LOW : URGENCY_MEDIUM, b->Type);
				}
			} else {
				b = &BuildingTypeClass::As_Reference(STRUCT_TENT);
				if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
					choiceptr = BuildChoice.Alloc();
					if (choiceptr != NULL) {
						*choiceptr = BuildChoiceClass(current > 0 ? URGENCY_LOW : URGENCY_MEDIUM, b->Type);
					}
				}
			}
		}

		/*
		**	Try to build one dog house.
		*/
		current = BQuantity[STRUCT_KENNEL];
		if (current < 1 && (money > 300 || hasincome)) {
			b = &BuildingTypeClass::As_Reference(STRUCT_KENNEL);
			if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
				choiceptr = BuildChoice.Alloc();
				if (choiceptr != NULL) {
					*choiceptr = BuildChoiceClass(URGENCY_MEDIUM, b->Type);
				}
			}
		}

		/*
		**	Try to build one gap generator.
		*/
		current = BQuantity[STRUCT_GAP];
		if (current < 1 && Power_Fraction() >= 1 && hasincome) {
			b = &BuildingTypeClass::As_Reference(STRUCT_GAP);
			if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
				choiceptr = BuildChoice.Alloc();
				if (choiceptr != NULL) {
					*choiceptr = BuildChoiceClass(URGENCY_MEDIUM, b->Type);
				}
			}
		}

		/*
		**	A source of combat vehicles is always needed, but only if there will
		**	be sufficient money to build vehicles.
		*/
		current = BQuantity[STRUCT_WEAP];
		if (current < Round_Up(Rule.WarRatio*fixed(CurBuildings)) && current < Rule.WarLimit && (money > 2000 || hasincome)) {
			b = &BuildingTypeClass::As_Reference(STRUCT_WEAP);
			if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
				choiceptr = BuildChoice.Alloc();
				if (choiceptr != NULL) {
					*choiceptr = BuildChoiceClass(current > 0 ? URGENCY_LOW : URGENCY_MEDIUM, b->Type);
				}
			}
		}

		/*
		**	Always build up some base defense.
		*/
		current = BQuantity[STRUCT_PILLBOX] + BQuantity[STRUCT_CAMOPILLBOX] + BQuantity[STRUCT_TURRET] + BQuantity[STRUCT_FLAME_TURRET];
		if (current < Round_Up(Rule.DefenseRatio*fixed(CurBuildings)) && current < Rule.DefenseLimit) {
			b = &BuildingTypeClass::As_Reference(STRUCT_FLAME_TURRET);
			if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
				choiceptr = BuildChoice.Alloc();
				if (choiceptr != NULL) {
					*choiceptr = BuildChoiceClass(URGENCY_MEDIUM, b->Type);
				}
			} else {
				if (Percent_Chance(50)) {
					b = &BuildingTypeClass::As_Reference(STRUCT_PILLBOX);
					if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
						choiceptr = BuildChoice.Alloc();
						if (choiceptr != NULL) {
							*choiceptr = BuildChoiceClass(URGENCY_MEDIUM, b->Type);
						}
					}
				} else {
					b = &BuildingTypeClass::As_Reference(STRUCT_TURRET);
					if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
						choiceptr = BuildChoice.Alloc();
						if (choiceptr != NULL) {
							*choiceptr = BuildChoiceClass(URGENCY_MEDIUM, b->Type);
						}
					}
				}
			}
		}

		/*
		**	Build some air defense.
		*/
		current = BQuantity[STRUCT_SAM] + BQuantity[STRUCT_AAGUN];
		if (current < Round_Up(Rule.AARatio*fixed(CurBuildings)) && current < Rule.AALimit) {

			/*
			**	Building air defense only makes sense if the opponent has aircraft
			**	of some kind.
			*/
			bool airthreat = false;
			int threat_quantity = 0;
			if (enemy != NULL && enemy->AScan != 0) {
				airthreat = true;
				threat_quantity = enemy->CurAircraft;
			}
			if (!airthreat) {
				for (HousesType house = HOUSE_FIRST; house < HOUSE_COUNT; house++) {
					HouseClass * h = HouseClass::As_Pointer(house);
					if (h != NULL && !Is_Ally(house) && h->AScan != 0) {
						airthreat = true;
						break;
					}
				}
			}

			if (airthreat) {

				if (BQuantity[STRUCT_RADAR] == 0) {
					b = &BuildingTypeClass::As_Reference(STRUCT_RADAR);
					if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
						choiceptr = BuildChoice.Alloc();
						if (choiceptr != NULL) {
							*choiceptr = BuildChoiceClass(URGENCY_HIGH, b->Type);
						}
					}
				}

				b = &BuildingTypeClass::As_Reference(STRUCT_SAM);
				if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
					choiceptr = BuildChoice.Alloc();
					if (choiceptr != NULL) {
						*choiceptr = BuildChoiceClass((current < threat_quantity) ? URGENCY_HIGH : URGENCY_MEDIUM, b->Type);
					}
				} else {
					b = &BuildingTypeClass::As_Reference(STRUCT_AAGUN);
					if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
						choiceptr = BuildChoice.Alloc();
						if (choiceptr != NULL) {
							*choiceptr = BuildChoiceClass((current < threat_quantity) ? URGENCY_HIGH : URGENCY_MEDIUM, b->Type);
						}
					}
				}
			}
		}

		/*
		**	Advanced base defense would be good.
		*/
		current = BQuantity[STRUCT_TESLA];
		if (current < Round_Up(Rule.TeslaRatio*fixed(CurBuildings)) && current < Rule.TeslaLimit) {
			b = &BuildingTypeClass::As_Reference(STRUCT_TESLA);
			if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome) && Power_Fraction() >= 1) {
				choiceptr = BuildChoice.Alloc();
				if (choiceptr != NULL) {
					*choiceptr = BuildChoiceClass(URGENCY_MEDIUM, b->Type);
				}
			}
		}

		/*
		**	Build a tech center as soon as possible.
		*/
		current = BQuantity[STRUCT_ADVANCED_TECH] + BQuantity[STRUCT_SOVIET_TECH];
		if (current < 1) {
			b = &BuildingTypeClass::As_Reference(STRUCT_ADVANCED_TECH);
			if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome) && Power_Fraction() >= 1) {
				choiceptr = BuildChoice.Alloc();
				if (choiceptr != NULL) {
					*choiceptr = BuildChoiceClass(URGENCY_MEDIUM, b->Type);
				}
			} else {
				b = &BuildingTypeClass::As_Reference(STRUCT_SOVIET_TECH);
				if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome) && Power_Fraction() >= 1) {
					choiceptr = BuildChoice.Alloc();
					if (choiceptr != NULL) {
						*choiceptr = BuildChoiceClass(URGENCY_MEDIUM, b->Type);
					}
				}
			}
		}

		/*
		**	A helipad would be good.
		*/
		current = BQuantity[STRUCT_HELIPAD];
		if (current < Round_Up(Rule.HelipadRatio*fixed(CurBuildings)) && current < Rule.HelipadLimit) {
			b = &BuildingTypeClass::As_Reference(STRUCT_HELIPAD);
			if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
				choiceptr = BuildChoice.Alloc();
				if (choiceptr != NULL) {
					int threat_quantity = 0;
					if (enemy != NULL) {
						threat_quantity = enemy->CurAircraft;
					}

					*choiceptr = BuildChoiceClass((CurAircraft < threat_quantity) ? URGENCY_HIGH : URGENCY_MEDIUM, b->Type);
				}
			}
		}

		/*
		**	An airstrip would be good.
		*/
		current = BQuantity[STRUCT_AIRSTRIP];
		if (current < Round_Up(Rule.AirstripRatio*fixed(CurBuildings)) && current < Rule.AirstripLimit) {
			b = &BuildingTypeClass::As_Reference(STRUCT_AIRSTRIP);
			if (Can_Build(b, ActLike) && (b->Cost_Of() < money || hasincome)) {
				choiceptr = BuildChoice.Alloc();
				if (choiceptr != NULL) {
					int threat_quantity = 0;
					if (enemy != NULL) {
						threat_quantity = enemy->CurAircraft;
					}

					*choiceptr = BuildChoiceClass((CurAircraft < threat_quantity) ? URGENCY_HIGH : URGENCY_MEDIUM, b->Type);
				}
			}
		}

#ifdef OLD
		/*
		**	Build a repair bay if there isn't one already available.
		*/
		current = BQuantity[STRUCT_REPAIR];
		if (current == 0) {
			b = &BuildingTypeClass::As_Reference(STRUCT_REPAIR);
			if (Can_Build(b, ActLike) && b->Cost_Of() < money) {
				choiceptr = BuildChoice.Alloc();
				if (choiceptr) {
					*choiceptr = BuildChoiceClass(URGENCY_MEDIUM, b->Type);
				}
			}
		}
#endif

		/*
		**	Pick the choice that is the most urgent.
		*/
		UrgencyType best = URGENCY_NONE;
		int bestindex;
		for (int index = 0; index < BuildChoice.Count(); index++) {
			if (BuildChoice.Ptr(index)->Urgency > best) {
				bestindex = index;
				best = BuildChoice.Ptr(index)->Urgency;
			}
		}
		if (best != URGENCY_NONE) {
			BuildStructure = BuildChoice.Ptr(bestindex)->Structure;
		}
	}

	return(TICKS_PER_SECOND);
}


/***********************************************************************************************
 * HouseClass::AI_Unit -- Determines what unit to build next.                                  *
 *                                                                                             *
 *    This routine handles the general case of determining what units to build next.           *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the number of games frames to delay before calling this routine again.*
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/29/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
int HouseClass::AI_Unit(void)
{
	assert(Houses.ID(this) == ID);

	if (BuildUnit != UNIT_NONE) return(TICKS_PER_SECOND);
	if (CurUnits >= Control.MaxUnit) return(TICKS_PER_SECOND);

	/*
	**	A computer controlled house will try to build a replacement
	**	harvester if possible.
	*/
	if (IQ >= Rule.IQHarvester && !IsTiberiumShort && !IsHuman && BQuantity[STRUCT_REFINERY] > UQuantity[UNIT_HARVESTER] && Difficulty != DIFF_HARD) {
		if (UnitTypeClass::As_Reference(UNIT_HARVESTER).Level <= Control.TechLevel) {
			BuildUnit = UNIT_HARVESTER;
			return(TICKS_PER_SECOND);
		}
	}

	if (Session.Type == GAME_NORMAL) {

		int counter[UNIT_COUNT];
		memset(counter, 0x00, sizeof(counter));

		/*
		**	Build a list of the maximum of each type we wish to produce. This will be
		**	twice the number required to fill all teams.
		*/
		for (int index = 0; index < Teams.Count(); index++) {
			TeamClass * tptr = Teams.Ptr(index);
			if (tptr != NULL) {
				TeamTypeClass const * team = tptr->Class;
				if (((team->IsReinforcable && !tptr->IsFullStrength) || (!tptr->IsForcedActive && !tptr->IsHasBeen && !tptr->JustAltered)) && team->House == Class->House) {
					for (int subindex = 0; subindex < team->ClassCount; subindex++) {
						TechnoTypeClass const * memtype = team->Members[subindex].Class;
						if (memtype->What_Am_I() == RTTI_UNITTYPE) {
							counter[((UnitTypeClass const *)memtype)->Type] = 1;
						}
					}
				}
			}
		}

		/*
		**	Team types that are flagged as prebuilt, will always try to produce enough
		**	to fill one team of this type regardless of whether there is a team active
		**	of that type.
		*/
		for (index = 0; index < TeamTypes.Count(); index++) {
			TeamTypeClass const * team = TeamTypes.Ptr(index);
			if (team != NULL && team->House == Class->House && team->IsPrebuilt && (!team->IsAutocreate || IsAlerted)) {
				for (int subindex = 0; subindex < team->ClassCount; subindex++) {
					TechnoTypeClass const * memtype = team->Members[subindex].Class;

					if (memtype->What_Am_I() == RTTI_UNITTYPE) {
						int subtype = ((UnitTypeClass const *)memtype)->Type;
						counter[subtype] = max(counter[subtype], team->Members[subindex].Quantity);
					}
				}
			}
		}

		/*
		**	Reduce the theoretical maximum by the actual number of objects currently
		**	in play.
		*/
		for (int uindex = 0; uindex < Units.Count(); uindex++) {
			UnitClass * unit = Units.Ptr(uindex);
			if (unit != NULL && unit->Is_Recruitable(this) && counter[unit->Class->Type] > 0) {
				counter[unit->Class->Type]--;
			}
		}

		/*
		**	Pick to build the most needed object but don't consider those objects that
		**	can't be built because of scenario restrictions or insufficient cash.
		*/
		int bestval = -1;
		int bestcount = 0;
		UnitType bestlist[UNIT_COUNT];
		for (UnitType utype = UNIT_FIRST; utype < UNIT_COUNT; utype++) {
			if (counter[utype] > 0 && Can_Build(&UnitTypeClass::As_Reference(utype), Class->House) && UnitTypeClass::As_Reference(utype).Cost_Of() <= Available_Money()) {
				if (bestval == -1 || bestval < counter[utype]) {
					bestval = counter[utype];
					bestcount = 0;
				}
				bestlist[bestcount++] = utype;
			}
		}

		/*
		**	The unit type to build is now known. Fetch a pointer to the techno type class.
		*/
		if (bestcount) {
			BuildUnit = bestlist[Random_Pick(0, bestcount-1)];
		}
	}

	if (IsBaseBuilding) {

		int counter[UNIT_COUNT];
		int total = 0;
		for (UnitType index = UNIT_FIRST; index < UNIT_COUNT; index++) {
			UnitTypeClass const * utype = &UnitTypeClass::As_Reference(index);
			if (Can_Build(utype, ActLike) && utype->Type != UNIT_HARVESTER) {
				if (utype->PrimaryWeapon != NULL) {
					counter[index] = 20;
				} else {
					counter[index] = 1;
				}
			} else {
				counter[index] = 0;
			}
			total += counter[index];
		}

		if (total > 0) {
			int choice = Random_Pick(0, total-1);
			for (index = UNIT_FIRST; index < UNIT_COUNT; index++) {
				if (choice < counter[index]) {
					BuildUnit = index;
					break;
				}
				choice -= counter[index];
			}
		}
	}

	return(TICKS_PER_SECOND);
}


int HouseClass::AI_Vessel(void)
{
	assert(Houses.ID(this) == ID);
	if (BuildVessel != VESSEL_NONE) return(TICKS_PER_SECOND);

	if (CurVessels >= Control.MaxVessel) {
		return(TICKS_PER_SECOND);
	}

	if (Session.Type == GAME_NORMAL) {

		int counter[VESSEL_COUNT];
		if (Session.Type == GAME_NORMAL) {
			memset(counter, 0x00, sizeof(counter));
		} else {
			for (VesselType index = VESSEL_FIRST; index < VESSEL_COUNT; index++) {
				if (Can_Build(&VesselTypeClass::As_Reference(index), Class->House) && VesselTypeClass::As_Reference(index).Level <= Control.TechLevel) {
					counter[index] = 16;
				} else {
					counter[index] = 0;
				}
			}
		}

		/*
		**	Build a list of the maximum of each type we wish to produce. This will be
		**	twice the number required to fill all teams.
		*/
		for (int index = 0; index < Teams.Count(); index++) {
			TeamClass * tptr = Teams.Ptr(index);
			if (tptr) {
				TeamTypeClass const * team = tptr->Class;

				if (((team->IsReinforcable && !tptr->IsFullStrength) || (!tptr->IsForcedActive && !tptr->IsHasBeen && !tptr->JustAltered)) && team->House == Class->House) {
					for (int subindex = 0; subindex < team->ClassCount; subindex++) {
						if (team->Members[subindex].Class->What_Am_I() == RTTI_VESSELTYPE) {
							counter[((VesselTypeClass const *)(team->Members[subindex].Class))->Type] = 1;
						}
					}
				}
			}
		}

		/*
		**	Team types that are flagged as prebuilt, will always try to produce enough
		**	to fill one team of this type regardless of whether there is a team active
		**	of that type.
		*/
		for (index = 0; index < TeamTypes.Count(); index++) {
			TeamTypeClass const * team = TeamTypes.Ptr(index);
			if (team) {
				if (team->House == Class->House && team->IsPrebuilt && (!team->IsAutocreate || IsAlerted)) {
					for (int subindex = 0; subindex < team->ClassCount; subindex++) {
						if (team->Members[subindex].Class->What_Am_I() == RTTI_VESSELTYPE) {
							int subtype = ((VesselTypeClass const *)(team->Members[subindex].Class))->Type;
							counter[subtype] = max(counter[subtype], team->Members[subindex].Quantity);
						}
					}
				}
			}
		}

		/*
		**	Reduce the theoretical maximum by the actual number of objects currently
		**	in play.
		*/
		for (int vindex = 0; vindex < Vessels.Count(); vindex++) {
			VesselClass * unit = Vessels.Ptr(vindex);
			if (unit != NULL && unit->Is_Recruitable(this) && counter[unit->Class->Type] > 0) {
				counter[unit->Class->Type]--;
			}
		}

		/*
		**	Pick to build the most needed object but don't consider those object that
		**	can't be built because of scenario restrictions or insufficient cash.
		*/
		int bestval = -1;
		int bestcount = 0;
		VesselType bestlist[VESSEL_COUNT];
		for (VesselType utype = VESSEL_FIRST; utype < VESSEL_COUNT; utype++) {
			if (counter[utype] > 0 && Can_Build(&VesselTypeClass::As_Reference(utype), Class->House) && VesselTypeClass::As_Reference(utype).Cost_Of() <= Available_Money()) {
				if (bestval == -1 || bestval < counter[utype]) {
					bestval = counter[utype];
					bestcount = 0;
				}
				bestlist[bestcount++] = utype;
			}
		}

		/*
		**	The unit type to build is now known. Fetch a pointer to the techno type class.
		*/
		if (bestcount) {
			BuildVessel = bestlist[Random_Pick(0, bestcount-1)];
		}
	}

	if (IsBaseBuilding) {
		BuildVessel = VESSEL_NONE;
	}

	return(TICKS_PER_SECOND);
}



/***********************************************************************************************
 * HouseClass::AI_Infantry -- Determines the infantry unit to build.                           *
 *                                                                                             *
 *    This routine handles the general case of determining what infantry unit to build         *
 *    next.                                                                                    *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the number of game frames to delay before being called again.         *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/29/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
int HouseClass::AI_Infantry(void)
{
	assert(Houses.ID(this) == ID);

	if (BuildInfantry != INFANTRY_NONE) return(TICKS_PER_SECOND);
	if (CurInfantry >= Control.MaxInfantry) return(TICKS_PER_SECOND);

	if (Session.Type == GAME_NORMAL) {
		TechnoTypeClass const * techno = 0;
		int counter[INFANTRY_COUNT];
		memset(counter, 0x00, sizeof(counter));

		/*
		**	Build a list of the maximum of each type we wish to produce. This will be
		**	twice the number required to fill all teams.
		*/
		for (int index = 0; index < Teams.Count(); index++) {
			TeamClass * tptr = Teams.Ptr(index);
			if (tptr != NULL) {
				TeamTypeClass const * team = tptr->Class;

				if (((team->IsReinforcable && !tptr->IsFullStrength) || (!tptr->IsForcedActive && !tptr->IsHasBeen && !tptr->JustAltered)) && team->House == Class->House) {
					for (int subindex = 0; subindex < team->ClassCount; subindex++) {
						if (team->Members[subindex].Class->What_Am_I() == RTTI_INFANTRYTYPE) {
							counter[((InfantryTypeClass const *)(team->Members[subindex].Class))->Type] += team->Members[subindex].Quantity + (team->IsReinforcable ? 1 : 0);
						}
					}
				}
			}
		}

		/*
		**	Team types that are flagged as prebuilt, will always try to produce enough
		**	to fill one team of this type regardless of whether there is a team active
		**	of that type.
		*/
		for (index = 0; index < TeamTypes.Count(); index++) {
			TeamTypeClass const * team = TeamTypes.Ptr(index);
			if (team != NULL) {
				if (team->House == Class->House && team->IsPrebuilt && (!team->IsAutocreate || IsAlerted)) {
					for (int subindex = 0; subindex < team->ClassCount; subindex++) {
						if (team->Members[subindex].Class->What_Am_I() == RTTI_INFANTRYTYPE) {
							int subtype = ((InfantryTypeClass const *)(team->Members[subindex].Class))->Type;
//									counter[subtype] = 1;
							counter[subtype] = max(counter[subtype], team->Members[subindex].Quantity);
							counter[subtype] = min(counter[subtype], 5);
						}
					}
				}
			}
		}

		/*
		**	Reduce the theoretical maximum by the actual number of objects currently
		**	in play.
		*/
		for (int uindex = 0; uindex < Infantry.Count(); uindex++) {
			InfantryClass * infantry = Infantry.Ptr(uindex);
			if (infantry != NULL && infantry->Is_Recruitable(this) && counter[infantry->Class->Type] > 0) {
				counter[infantry->Class->Type]--;
			}
		}

		/*
		**	Pick to build the most needed object but don't consider those object that
		**	can't be built because of scenario restrictions or insufficient cash.
		*/
		int bestval = -1;
		int bestcount = 0;
		InfantryType bestlist[INFANTRY_COUNT];
		for (InfantryType utype = INFANTRY_FIRST; utype < INFANTRY_COUNT; utype++) {

			if (utype != INFANTRY_DOG || !(IScan & INFANTRYF_DOG)) {
				if (counter[utype] > 0 && Can_Build(&InfantryTypeClass::As_Reference(utype), Class->House) && InfantryTypeClass::As_Reference(utype).Cost_Of() <= Available_Money()) {
					if (bestval == -1 || bestval < counter[utype]) {
						bestval = counter[utype];
						bestcount = 0;
					}
					bestlist[bestcount++] = utype;
				}
			}
		}

		/*
		**	The infantry type to build is now known. Fetch a pointer to the techno type class.
		*/
		if (bestcount) {
			int pick = Random_Pick(0, bestcount-1);
			BuildInfantry = bestlist[pick];
		}

	}

	if (IsBaseBuilding) {
		HouseClass const * enemy = NULL;
		if (Enemy != HOUSE_NONE) {
			enemy = HouseClass::As_Pointer(Enemy);
		}

		/*
		**	This structure is used to keep track of the list of infantry types that should be
		**	built. The infantry type and the value assigned to it is recorded.
		*/
		struct {
			InfantryType	Type;		// Infantry type.
			int				Value;	// Relative value assigned.
		} typetrack[INFANTRY_COUNT];
		int count = 0;
		int total = 0;
		for (InfantryType index = INFANTRY_FIRST; index < INFANTRY_COUNT; index++) {
			if (Can_Build(&InfantryTypeClass::As_Reference(index), ActLike) && InfantryTypeClass::As_Reference(index).Level <= Control.TechLevel) {
				typetrack[count].Value = 0;
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98 This looks like a potential bug. It is prob. for save game format compatibility.
				int clipindex = index;
				if (clipindex >= INFANTRY_RA_COUNT) clipindex -= INFANTRY_RA_COUNT;
				if ((enemy != NULL && enemy->IQuantity[clipindex] > IQuantity[clipindex]) || Available_Money() > Rule.InfantryReserve || CurInfantry < CurBuildings * Rule.InfantryBaseMult) {
#else
				if ((enemy != NULL && enemy->IQuantity[index] > IQuantity[index]) || Available_Money() > Rule.InfantryReserve || CurInfantry < CurBuildings * Rule.InfantryBaseMult) {
#endif

					switch (index) {
						case INFANTRY_E1:
							typetrack[count].Value = 3;
							break;

						case INFANTRY_E2:
							typetrack[count].Value = 5;
							break;

						case INFANTRY_E3:
							typetrack[count].Value = 2;
							break;

						case INFANTRY_E4:
							typetrack[count].Value = 5;
							break;

						case INFANTRY_RENOVATOR:
							if (CurInfantry > 5) {
								typetrack[count].Value = 1 - max(IQuantity[index], 0);
							}
							break;

						case INFANTRY_TANYA:
							typetrack[count].Value = 1 - max(IQuantity[index], 0);
							break;

						default:
							typetrack[count].Value = 0;
							break;
					}
				}

				if (typetrack[count].Value > 0) {
					typetrack[count].Type = index;
					total += typetrack[count].Value;
					count++;
				}
			}
		}

		/*
		**	If there is at least one choice, then pick it. The object picked
		**	is influenced by the weight (value) assigned to it. This is accomplished
		**	by picking a number between 0 and the total weight value. The appropriate
		**	infantry object that matches the number picked is then selected to be built.
		*/
		if (count > 0) {
			int pick = Random_Pick(0, total-1);
			for (int index = 0; index < count; index++) {
				if (pick < typetrack[index].Value) {
					BuildInfantry = typetrack[index].Type;
					break;
				}
				pick -= typetrack[index].Value;
			}
		}
	}
	return(TICKS_PER_SECOND);
}


/***********************************************************************************************
 * HouseClass::AI_Aircraft -- Determines what aircraft to build next.                          *
 *                                                                                             *
 *    This routine is used to determine the general case of what aircraft to build next.       *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the number of frame to delay before calling this routine again.       *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/29/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
int HouseClass::AI_Aircraft(void)
{
	assert(Houses.ID(this) == ID);

	if (!IsHuman && IQ >= Rule.IQAircraft) {
		if (BuildAircraft != AIRCRAFT_NONE) return(TICKS_PER_SECOND);
		if (CurAircraft >= Control.MaxAircraft) return(TICKS_PER_SECOND);

		if (Can_Build(&AircraftTypeClass::As_Reference(AIRCRAFT_LONGBOW), ActLike) &&
				 AircraftTypeClass::As_Reference(AIRCRAFT_LONGBOW).Level <= Control.TechLevel &&
				 BQuantity[STRUCT_HELIPAD] > AQuantity[AIRCRAFT_LONGBOW] + AQuantity[AIRCRAFT_HIND]) {
			BuildAircraft = AIRCRAFT_LONGBOW;
			return(TICKS_PER_SECOND);
		}

		if (Can_Build(&AircraftTypeClass::As_Reference(AIRCRAFT_HIND), ActLike) &&
				 AircraftTypeClass::As_Reference(AIRCRAFT_HIND).Level <= Control.TechLevel &&
				 BQuantity[STRUCT_HELIPAD] > AQuantity[AIRCRAFT_LONGBOW] + AQuantity[AIRCRAFT_HIND]) {
			BuildAircraft = AIRCRAFT_HIND;
			return(TICKS_PER_SECOND);
		}

		if (Can_Build(&AircraftTypeClass::As_Reference(AIRCRAFT_MIG), ActLike) &&
				 AircraftTypeClass::As_Reference(AIRCRAFT_MIG).Level <= Control.TechLevel &&
				 BQuantity[STRUCT_AIRSTRIP] > AQuantity[AIRCRAFT_MIG] + AQuantity[AIRCRAFT_YAK]) {
			BuildAircraft = AIRCRAFT_MIG;
			return(TICKS_PER_SECOND);
		}

		if (Can_Build(&AircraftTypeClass::As_Reference(AIRCRAFT_YAK), ActLike) &&
				 AircraftTypeClass::As_Reference(AIRCRAFT_YAK).Level <= Control.TechLevel &&
				 BQuantity[STRUCT_AIRSTRIP] > AQuantity[AIRCRAFT_MIG] + AQuantity[AIRCRAFT_YAK]) {
			BuildAircraft = AIRCRAFT_YAK;
			return(TICKS_PER_SECOND);
		}
	}

	return(TICKS_PER_SECOND);
}


/***********************************************************************************************
 * HouseClass::Production_Begun -- Records that production has begun.                          *
 *                                                                                             *
 *    This routine is used to inform the Expert System that production of the specified object *
 *    has begun. This allows the AI to proceed with picking another object to begin production *
 *    on.                                                                                      *
 *                                                                                             *
 * INPUT:   product  -- Pointer to the object that production has just begun on.               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/29/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Production_Begun(TechnoClass const * product)
{
	assert(Houses.ID(this) == ID);

	if (product != NULL) {
		switch (product->What_Am_I()) {
			case RTTI_UNIT:
				if (*((UnitClass*)product) == BuildUnit) {
					BuildUnit = UNIT_NONE;
				}
				break;

			case RTTI_VESSEL:
				if (*((VesselClass*)product) == BuildVessel) {
					BuildVessel = VESSEL_NONE;
				}
				break;

			case RTTI_INFANTRY:
				if (*((InfantryClass*)product) == BuildInfantry) {
					BuildInfantry = INFANTRY_NONE;
				}
				break;

			case RTTI_BUILDING:
				if (*((BuildingClass*)product) == BuildStructure) {
					BuildStructure = STRUCT_NONE;
				}
				break;

			case RTTI_AIRCRAFT:
				if (*((AircraftClass*)product) == BuildAircraft) {
					BuildAircraft = AIRCRAFT_NONE;
				}
				break;

			default:
				break;
		}
	}
}


/***********************************************************************************************
 * HouseClass::Tracking_Remove -- Remove object from house tracking system.                    *
 *                                                                                             *
 *    This routine informs the Expert System that the specified object is no longer part of    *
 *    this house's inventory. This occurs when the object is destroyed or captured.            *
 *                                                                                             *
 * INPUT:   techno   -- Pointer to the object to remove from the tracking systems of this      *
 *                      house.                                                                 *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/29/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Tracking_Remove(TechnoClass const * techno)
{
	assert(Houses.ID(this) == ID);

	int type;

	switch (techno->What_Am_I()) {
		case RTTI_BUILDING:
			CurBuildings--;
			BQuantity[((BuildingTypeClass const &)techno->Class_Of()).Type]--;
			break;

		case RTTI_AIRCRAFT:
			CurAircraft--;
			AQuantity[((AircraftTypeClass const &)techno->Class_Of()).Type]--;
			break;

		case RTTI_INFANTRY:
			CurInfantry--;
			if (!((InfantryClass *)techno)->IsTechnician) {
				type = ((InfantryTypeClass const &)techno->Class_Of()).Type;
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
				if (type >= INFANTRY_RA_COUNT) type -= INFANTRY_RA_COUNT;
#endif
				IQuantity[type]--;
			}
			break;

		case RTTI_UNIT:
			CurUnits--;
			type = ((UnitTypeClass const &)techno->Class_Of()).Type;
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
			if (type >= UNIT_RA_COUNT) type -= UNIT_RA_COUNT;
#endif
			UQuantity[type]--;
			break;

		case RTTI_VESSEL:
			CurVessels--;
			type = ((VesselTypeClass const &)techno->Class_Of()).Type;
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
			if (type >= VESSEL_RA_COUNT) type -= VESSEL_RA_COUNT;
#endif
			VQuantity[type]--;
			break;

		default:
			break;
	}
}


/***********************************************************************************************
 * HouseClass::Tracking_Add -- Informs house of new inventory item.                            *
 *                                                                                             *
 *    This function is called when the specified object is now available as part of the house's*
 *    inventory. This occurs when the object is newly produced and also when it is captured    *
 *    by this house.                                                                           *
 *                                                                                             *
 * INPUT:   techno   -- Pointer to the object that is now part of the house inventory.         *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/29/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Tracking_Add(TechnoClass const * techno)
{
	assert(Houses.ID(this) == ID);

	StructType building;
	AircraftType aircraft;
	InfantryType infantry;
	UnitType unit;
	VesselType vessel;
	int quant;

	switch (techno->What_Am_I()) {
		case RTTI_BUILDING:
			CurBuildings++;
			building = ((BuildingTypeClass const &)techno->Class_Of()).Type;
			BQuantity[building]++;
			BScan |= (1L << building);
			if (Session.Type == GAME_INTERNET) {
				BuildingTotals->Increment_Unit_Total(techno->Class_Of().ID);
			}
			break;

		case RTTI_AIRCRAFT:
			CurAircraft++;
			aircraft = ((AircraftTypeClass const &)techno->Class_Of()).Type;
			AQuantity[aircraft]++;
			AScan |= (1L << aircraft);
			if (Session.Type == GAME_INTERNET) {
				AircraftTotals->Increment_Unit_Total(techno->Class_Of().ID);
			}
			break;

		case RTTI_INFANTRY:
			CurInfantry++;
			infantry = ((InfantryTypeClass const &)techno->Class_Of()).Type;
			if (!((InfantryClass *)techno)->IsTechnician) {
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
				quant = infantry;
				if (quant >= INFANTRY_RA_COUNT) quant -= INFANTRY_RA_COUNT;
				IQuantity[quant]++;
#else
				IQuantity[infantry]++;
#endif
				if (!((InfantryTypeClass const &)techno->Class_Of()).IsCivilian && Session.Type == GAME_INTERNET) {
					InfantryTotals->Increment_Unit_Total(techno->Class_Of().ID);
				}
				IScan |= (1L << infantry);
			}
			break;

		case RTTI_UNIT:
			CurUnits++;
			unit = ((UnitTypeClass const &)techno->Class_Of()).Type;
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
			quant = unit;
			if (quant >= UNIT_RA_COUNT) quant -= UNIT_RA_COUNT;
			UQuantity[quant]++;
#else
			UQuantity[unit]++;
#endif
			UScan |= (1L << unit);
			if (Session.Type == GAME_INTERNET) {
				UnitTotals->Increment_Unit_Total(techno->Class_Of().ID);
			}
			break;

		case RTTI_VESSEL:
			CurVessels++;
			vessel = ((VesselTypeClass const &)techno->Class_Of()).Type;
#ifdef FIXIT_CSII	//	checked - ajw 9/28/98
			quant = vessel;
			if (quant >= VESSEL_RA_COUNT) quant -= VESSEL_RA_COUNT;
			VQuantity[quant]++;
#else
			VQuantity[vessel]++;
#endif
			VScan |= (1L << vessel);
			if (Session.Type == GAME_INTERNET) {
				VesselTotals->Increment_Unit_Total(techno->Class_Of().ID);
			}
			break;

		default:
			break;
	}
}


/***********************************************************************************************
 * HouseClass::Factory_Counter -- Fetches a pointer to the factory counter value.              *
 *                                                                                             *
 *    Use this routine to fetch a pointer to the variable that holds the number of factories   *
 *    that can produce the specified object type. This is a helper routine used when           *
 *    examining the number of factories as well as adjusting their number.                     *
 *                                                                                             *
 * INPUT:   rtti  -- The RTTI of the object that could be produced.                            *
 *                                                                                             *
 * OUTPUT:  Returns with the number of factories owned by this house that could produce the    *
 *          object of the type specified.                                                      *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/30/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
int * HouseClass::Factory_Counter(RTTIType rtti)
{
	switch (rtti) {
		case RTTI_UNITTYPE:
		case RTTI_UNIT:
			return(&UnitFactories);

		case RTTI_VESSELTYPE:
		case RTTI_VESSEL:
			return(&VesselFactories);

		case RTTI_AIRCRAFTTYPE:
		case RTTI_AIRCRAFT:
			return(&AircraftFactories);

		case RTTI_INFANTRYTYPE:
		case RTTI_INFANTRY:
			return(&InfantryFactories);

		case RTTI_BUILDINGTYPE:
		case RTTI_BUILDING:
			return(&BuildingFactories);

		default:
			break;
	}
	return(NULL);
}


/***********************************************************************************************
 * HouseClass::Active_Remove -- Remove this object from active duty for this house.            *
 *                                                                                             *
 *    This routine will recognize the specified object as having been removed from active      *
 *    duty.                                                                                    *
 *                                                                                             *
 * INPUT:   techno   -- Pointer to the object to remove from active duty.                      *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/16/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Active_Remove(TechnoClass const * techno)
{
	if (techno == NULL) return;

	if (techno->What_Am_I() == RTTI_BUILDING) {
		int * fptr = Factory_Counter(((BuildingClass *)techno)->Class->ToBuild);
		if (fptr != NULL) {
			*fptr = *fptr - 1;
		}
	}
}


/***********************************************************************************************
 * HouseClass::Active_Add -- Add an object to active duty for this house.                      *
 *                                                                                             *
 *    This routine will recognize the specified object as having entered active duty. Any      *
 *    abilities granted to the house by that object are now available.                         *
 *                                                                                             *
 * INPUT:   techno   -- Pointer to the object that is entering active duty.                    *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/16/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Active_Add(TechnoClass const * techno)
{
	if (techno == NULL) return;

	if (techno->What_Am_I() == RTTI_BUILDING) {
		int * fptr = Factory_Counter(((BuildingClass *)techno)->Class->ToBuild);
		if (fptr != NULL) {
			*fptr = *fptr + 1;
		}
	}
}


/***********************************************************************************************
 * HouseClass::Which_Zone -- Determines what zone a coordinate lies in.                        *
 *                                                                                             *
 *    This routine will determine what zone the specified coordinate lies in with respect to   *
 *    this house's base. A location that is too distant from the base, even though it might    *
 *    be a building, is not considered part of the base and returns ZONE_NONE.                 *
 *                                                                                             *
 * INPUT:   coord -- The coordinate to examine.                                                *
 *                                                                                             *
 * OUTPUT:  Returns with the base zone that the specified coordinate lies in.                  *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/02/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
ZoneType HouseClass::Which_Zone(COORDINATE coord) const
{
	assert(Houses.ID(this) == ID);

	if (coord == 0) return(ZONE_NONE);

	int distance = Distance(Center, coord);
	if (distance <= Radius) return(ZONE_CORE);
	if (distance > Radius*4) return(ZONE_NONE);

	DirType facing = Direction(Center, coord);
	if (facing < DIR_NE || facing > DIR_NW) return(ZONE_NORTH);
	if (facing >= DIR_NE && facing < DIR_SE) return(ZONE_EAST);
	if (facing >= DIR_SE && facing < DIR_SW) return(ZONE_SOUTH);
	return(ZONE_WEST);
}


/***********************************************************************************************
 * HouseClass::Which_Zone -- Determines which base zone the specified object lies in.          *
 *                                                                                             *
 *    Use this routine to determine what zone the specified object lies in.                    *
 *                                                                                             *
 * INPUT:   object   -- Pointer to the object that will be checked for zone occupation.        *
 *                                                                                             *
 * OUTPUT:  Returns with the base zone that the object lies in. For objects that are too       *
 *          distant from the center of the base, ZONE_NONE is returned.                        *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/02/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
ZoneType HouseClass::Which_Zone(ObjectClass const * object) const
{
	assert(Houses.ID(this) == ID);

	if (!object) return(ZONE_NONE);
	return(Which_Zone(object->Center_Coord()));
}


/***********************************************************************************************
 * HouseClass::Which_Zone -- Determines which base zone the specified cell lies in.            *
 *                                                                                             *
 *    This routine is used to determine what base zone the specified cell is in.               *
 *                                                                                             *
 * INPUT:   cell  -- The cell to examine.                                                      *
 *                                                                                             *
 * OUTPUT:  Returns the base zone that the cell lies in or ZONE_NONE if the cell is too far    *
 *          away.                                                                              *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/02/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
ZoneType HouseClass::Which_Zone(CELL cell) const
{
	assert(Houses.ID(this) == ID);

	return(Which_Zone(Cell_Coord(cell)));
}


/***********************************************************************************************
 * HouseClass::Recalc_Attributes -- Recalcs all houses existence bits.                         *
 *                                                                                             *
 *    This routine will go through all game objects and reset the existence bits for the       *
 *    owning house. This method ensures that if the object exists, then the corresponding      *
 *    existence bit is also set.                                                               *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/02/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Recalc_Attributes(void)
{
	/*
	**	Clear out all tracking values that will be filled in by this
	**	routine. This allows the filling in process to not worry about
	**	old existing values.
	*/
	for (int index = 0; index < Houses.Count(); index++) {
		HouseClass * house = Houses.Ptr(index);

		if (house != NULL) {
			house->BScan = 0;
			house->ActiveBScan = 0;
			house->IScan = 0;
			house->ActiveIScan = 0;
			house->UScan = 0;
			house->ActiveUScan = 0;
			house->AScan = 0;
			house->ActiveAScan = 0;
			house->VScan = 0;
			house->ActiveVScan = 0;
		}
	}

	/*
	**	A second pass through the sentient objects is required so that the appropriate scan
	**	bits will be set for the owner house.
	*/
	for (index = 0; index < Units.Count(); index++) {
		UnitClass const * unit = Units.Ptr(index);
		unit->House->UScan |= (1L << unit->Class->Type);
		if (unit->IsLocked && (Session.Type != GAME_NORMAL || !unit->House->IsHuman || unit->IsDiscoveredByPlayer)) {
			if (!unit->IsInLimbo) {
				unit->House->ActiveUScan |= (1L << unit->Class->Type);
			}
		}
	}
	for (index = 0; index < Infantry.Count(); index++) {
		InfantryClass const * infantry = Infantry.Ptr(index);
		infantry->House->IScan |= (1L << infantry->Class->Type);
		if (infantry->IsLocked && (Session.Type != GAME_NORMAL || !infantry->House->IsHuman || infantry->IsDiscoveredByPlayer)) {
			if (!infantry->IsInLimbo) {
				infantry->House->ActiveIScan |= (1L << infantry->Class->Type);
				infantry->House->OldIScan |= (1L << infantry->Class->Type);
			}
		}
	}
	for (index = 0; index < Aircraft.Count(); index++) {
		AircraftClass const * aircraft = Aircraft.Ptr(index);
		aircraft->House->AScan |= (1L << aircraft->Class->Type);
		if (aircraft->IsLocked && (Session.Type != GAME_NORMAL || !aircraft->House->IsHuman || aircraft->IsDiscoveredByPlayer)) {
			if (!aircraft->IsInLimbo) {
				aircraft->House->ActiveAScan |= (1L << aircraft->Class->Type);
				aircraft->House->OldAScan |= (1L << aircraft->Class->Type);
			}
		}
	}
	for (index = 0; index < Buildings.Count(); index++) {
		BuildingClass const * building = Buildings.Ptr(index);
		if (building->Class->Type < 32) {
			building->House->BScan |= (1L << building->Class->Type);
			if (building->IsLocked && (Session.Type != GAME_NORMAL || !building->House->IsHuman || building->IsDiscoveredByPlayer)) {
				if (!building->IsInLimbo) {
					building->House->ActiveBScan |= (1L << building->Class->Type);
					building->House->OldBScan |= (1L << building->Class->Type);
				}
			}
		}
	}
	for (index = 0; index < Vessels.Count(); index++) {
		VesselClass const * vessel = Vessels.Ptr(index);
		vessel->House->VScan |= (1L << vessel->Class->Type);
		if (vessel->IsLocked && (Session.Type != GAME_NORMAL || !vessel->House->IsHuman || vessel->IsDiscoveredByPlayer)) {
			if (!vessel->IsInLimbo) {
				vessel->House->ActiveVScan |= (1L << vessel->Class->Type);
				vessel->House->OldVScan |= (1L << vessel->Class->Type);
			}
		}
	}
}


/***********************************************************************************************
 * HouseClass::Zone_Cell -- Finds the cell closest to the center of the zone.                  *
 *                                                                                             *
 *    This routine is used to find the cell that is closest to the center point of the         *
 *    zone specified. Typical use of this routine is for building and unit placement so that   *
 *    they can "cover" the specified zone.                                                     *
 *                                                                                             *
 * INPUT:   zone  -- The zone that the center point is to be returned.                         *
 *                                                                                             *
 * OUTPUT:  Returns with the cell that is closest to the center point of the zone specified.   *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/02/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
CELL HouseClass::Zone_Cell(ZoneType zone) const
{
	assert(Houses.ID(this) == ID);

	switch (zone) {
		case ZONE_CORE:
			return(Coord_Cell(Center));

		case ZONE_NORTH:
			return(Coord_Cell(Coord_Move(Center, DIR_N, Radius*3)));

		case ZONE_EAST:
			return(Coord_Cell(Coord_Move(Center, DIR_E, Radius*3)));

		case ZONE_WEST:
			return(Coord_Cell(Coord_Move(Center, DIR_W, Radius*3)));

		case ZONE_SOUTH:
			return(Coord_Cell(Coord_Move(Center, DIR_S, Radius*3)));

		default:
			break;
	}
	return(0);
}


/***********************************************************************************************
 * HouseClass::Where_To_Go -- Determines where the object should go and wait.                  *
 *                                                                                             *
 *    This function is called for every new unit produced or delivered in order to determine   *
 *    where the unit should "hang out" to await further orders. The best area for the          *
 *    unit to loiter is returned as a cell location.                                           *
 *                                                                                             *
 * INPUT:   object   -- Pointer to the object that needs to know where to go.                  *
 *                                                                                             *
 * OUTPUT:  Returns with the cell that the unit should move to.                                *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/02/1995 JLB : Created.                                                                 *
 *   11/04/1996 JLB : Simplified to use helper functions                                       *
 *=============================================================================================*/
CELL HouseClass::Where_To_Go(FootClass const * object) const
{
	assert(Houses.ID(this) == ID);
	assert(object != NULL);

	ZoneType zone;			// The zone that the object should go to.
	if (object->Anti_Air() + object->Anti_Armor() + object->Anti_Infantry() == 0) {
		zone = ZONE_CORE;
	} else {
		zone = Random_Pick(ZONE_NORTH, ZONE_WEST);
	}

	CELL cell = Random_Cell_In_Zone(zone);
	assert(cell != 0);

	return(Map.Nearby_Location(cell, SPEED_TRACK, Map[cell].Zones[MZONE_NORMAL], MZONE_NORMAL));
}


/***********************************************************************************************
 * HouseClass::Find_Juicy_Target -- Finds a suitable field target.                             *
 *                                                                                             *
 *    This routine is used to find targets out in the field and away from base defense.        *
 *    Typical of this would be the attack helicopters and the roving attack bands of           *
 *    hunter killers.                                                                          *
 *                                                                                             *
 * INPUT:   coord -- The coordinate of the attacker. Closer targets are given preference.      *
 *                                                                                             *
 * OUTPUT:  Returns with a suitable target to attack.                                          *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/12/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
TARGET HouseClass::Find_Juicy_Target(COORDINATE coord) const
{
	assert(Houses.ID(this) == ID);

	UnitClass * best = 0;
	int value = 0;

	for (int index = 0; index < Units.Count(); index++) {
		UnitClass * unit = Units.Ptr(index);

		if (unit && !unit->IsInLimbo && !Is_Ally(unit) && unit->House->Which_Zone(unit) == ZONE_NONE) {
			int val = Distance(coord, unit->Center_Coord());

			if (unit->Anti_Air()) val *= 2;

			if (*unit == UNIT_HARVESTER) val /= 2;

			if (value == 0 || val < value) {
				value = val;
				best = unit;
			}
		}
	}
	if (best) {
		return(best->As_Target());
	}
	return(TARGET_NONE);
}


/***********************************************************************************************
 * HouseClass::Get_Quantity -- Fetches the total number of aircraft of the specified type.     *
 *                                                                                             *
 *    Call this routine to fetch the total quantity of aircraft of the type specified that is  *
 *    owned by this house.                                                                     *
 *                                                                                             *
 * INPUT:   aircraft -- The aircraft type to check the quantity of.                            *
 *                                                                                             *
 * OUTPUT:  Returns with the total quantity of all aircraft of that type that is owned by this *
 *          house.                                                                             *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/09/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
int  HouseClass::Get_Quantity(AircraftType aircraft)
{
	return(AQuantity[aircraft]);
}


/***********************************************************************************************
 * HouseClass::Fetch_Factory -- Finds the factory associated with the object type specified.   *
 *                                                                                             *
 *    This is the counterpart to the Set_Factory function. It will return with a factory       *
 *    pointer that is associated with the object type specified.                               *
 *                                                                                             *
 * INPUT:   rtti  -- The RTTI of the object type to find the factory for.                      *
 *                                                                                             *
 * OUTPUT:  Returns with a pointer to the factory (if present) that can manufacture the        *
 *          object type specified.                                                             *
 *                                                                                             *
 * WARNINGS:   If this returns a non-NULL pointer, then the factory is probably already busy   *
 *             producing another unit of that category.                                        *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/09/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
FactoryClass * HouseClass::Fetch_Factory(RTTIType rtti) const
{
	int factory_index = -1;

	switch (rtti) {
		case RTTI_INFANTRY:
		case RTTI_INFANTRYTYPE:
			factory_index = InfantryFactory;
			break;

		case RTTI_UNIT:
		case RTTI_UNITTYPE:
			factory_index = UnitFactory;
			break;

		case RTTI_BUILDING:
		case RTTI_BUILDINGTYPE:
			factory_index = BuildingFactory;
			break;

		case RTTI_AIRCRAFT:
		case RTTI_AIRCRAFTTYPE:
			factory_index = AircraftFactory;
			break;

		case RTTI_VESSEL:
		case RTTI_VESSELTYPE:
			factory_index = VesselFactory;
			break;

		default:
			factory_index = -1;
			break;
	}

	/*
	**	Fetch the actual pointer to the factory object. If there is
	**	no object factory that matches the specified rtti type, then
	**	null is returned.
	*/
	if (factory_index != -1) {
		return(Factories.Raw_Ptr(factory_index));
	}
	return(NULL);
}


/***********************************************************************************************
 * HouseClass::Set_Factory -- Assign specified factory to house tracking.                      *
 *                                                                                             *
 *    Call this routine when a factory has been created and it now must be passed on to the    *
 *    house for tracking purposes. The house maintains several factory pointers and this       *
 *    routine will ensure that the factory pointer gets stored correctly.                      *
 *                                                                                             *
 * INPUT:   rtti  -- The RTTI of the object the factory it to manufacture.                     *
 *                                                                                             *
 *          factory  -- The factory object pointer.                                            *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/09/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Set_Factory(RTTIType rtti, FactoryClass * factory)
{
	int * factory_index = 0;

	assert(rtti != RTTI_NONE);

	switch (rtti) {
		case RTTI_UNIT:
		case RTTI_UNITTYPE:
			factory_index = &UnitFactory;
			break;

		case RTTI_INFANTRY:
		case RTTI_INFANTRYTYPE:
			factory_index = &InfantryFactory;
			break;

		case RTTI_VESSEL:
		case RTTI_VESSELTYPE:
			factory_index = &VesselFactory;
			break;

		case RTTI_BUILDING:
		case RTTI_BUILDINGTYPE:
			factory_index = &BuildingFactory;
			break;

		case RTTI_AIRCRAFT:
		case RTTI_AIRCRAFTTYPE:
			factory_index = &AircraftFactory;
			break;
	}

	assert(factory_index != NULL);

	/*
	**	Assign the factory to the appropriate slot. For the case of clearing
	**	the factory out, then -1 is assigned.
	*/
	if (factory != NULL) {
		*factory_index = factory->ID;
	} else {
		*factory_index = -1;
	}
}


/***********************************************************************************************
 * HouseClass::Factory_Count -- Fetches the number of factories for specified type.            *
 *                                                                                             *
 *    This routine will count the number of factories owned by this house that can build       *
 *    objects of the specified type.                                                           *
 *                                                                                             *
 * INPUT:   rtti  -- The type of object (RTTI) that the factories are to be counted for.       *
 *                                                                                             *
 * OUTPUT:  Returns with the number of factories that can build the object type specified.     *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/30/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
int HouseClass::Factory_Count(RTTIType rtti) const
{
	int const * ptr = ((HouseClass *)this)->Factory_Counter(rtti);
	if (ptr != NULL) {
		return(*ptr);
	}
	return(0);
}


/***********************************************************************************************
 * HouseClass::Get_Quantity -- Gets the quantity of the building type specified.               *
 *                                                                                             *
 *    This will return the total number of buildings of that type owned by this house.         *
 *                                                                                             *
 * INPUT:   building -- The building type to check.                                            *
 *                                                                                             *
 * OUTPUT:  Returns with the number of buildings of that type owned by this house.             *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/09/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
int  HouseClass::Get_Quantity(StructType building)
{
	return(BQuantity[building]);
}


/***********************************************************************************************
 * HouseClass::Read_INI -- Reads house specific data from INI.                                 *
 *                                                                                             *
 *    This routine reads the house specific data for a particular                              *
 *    scenario from the scenario INI file. Typical data includes starting                      *
 *    credits, maximum unit count, etc.                                                        *
 *                                                                                             *
 * INPUT:   buffer   -- Pointer to loaded scenario INI file.                                   *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/24/1994 JLB : Created.                                                                 *
 *   05/18/1995 JLB : Creates all houses.                                                      *
 *=============================================================================================*/
void HouseClass::Read_INI(CCINIClass & ini)
{
	HouseClass 	* p;				// Pointer to current player data.
	char const	* hname;			//	Pointer to house name.

	for (HousesType index = HOUSE_FIRST; index < HOUSE_COUNT; index++) {
		hname = HouseTypeClass::As_Reference(index).IniName;

		p = new HouseClass(index);
		p->Control.TechLevel = ini.Get_Int(hname, "TechLevel", Scen.Scenario);
		p->Control.MaxBuilding = ini.Get_Int(hname, "MaxBuilding", p->Control.MaxBuilding);
		p->Control.MaxUnit = ini.Get_Int(hname, "MaxUnit", p->Control.MaxUnit);
		p->Control.MaxInfantry = ini.Get_Int(hname, "MaxInfantry", p->Control.MaxInfantry);
		p->Control.MaxVessel = ini.Get_Int(hname, "MaxVessel", p->Control.MaxVessel);
		if (p->Control.MaxVessel == 0) p->Control.MaxVessel = p->Control.MaxUnit;
		p->Control.InitialCredits = ini.Get_Int(hname, "Credits", 0) * 100;
		p->Credits = p->Control.InitialCredits;

		int iq = ini.Get_Int(hname, "IQ", 0);
		if (iq > Rule.MaxIQ) iq = 1;
		p->IQ = p->Control.IQ = iq;

		p->Control.Edge = ini.Get_SourceType(hname, "Edge", SOURCE_NORTH);
		p->IsPlayerControl = ini.Get_Bool(hname, "PlayerControl", false);

		int owners = ini.Get_Owners(hname, "Allies", (1 << HOUSE_NEUTRAL));
		p->Make_Ally(index);
		p->Make_Ally(HOUSE_NEUTRAL);
		for (HousesType h = HOUSE_FIRST; h < HOUSE_COUNT; h++) {
			if ((owners & (1 << h)) != 0) {
				p->Make_Ally(h);
			}
		}
	}
}


/***********************************************************************************************
 * HouseClass::Write_INI -- Writes the house data to the INI database.                         *
 *                                                                                             *
 *    This routine will write out all data necessary to recreate it in anticipation of a       *
 *    new scenario. All houses (that are active) will have their scenario type data written    *
 *    out.                                                                                     *
 *                                                                                             *
 * INPUT:   ini   -- Reference to the INI database to write the data to.                       *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/09/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Write_INI(CCINIClass & ini)
{
	/*
	**	The identity house control object. Only if the house value differs from the
	**	identity, will the data be written out.
	*/
	HouseStaticClass control;

	for (HousesType i = HOUSE_FIRST; i < HOUSE_COUNT; i++) {
		HouseClass * p = As_Pointer(i);

		if (p != NULL) {
			char const * name = p->Class->IniName;

			ini.Clear(name);
			if (i >= HOUSE_MULTI1) continue;

			if (p->Control.InitialCredits != control.InitialCredits) {
				ini.Put_Int(name, "Credits", (int)(p->Control.InitialCredits / 100));
			}

			if (p->Control.Edge != control.Edge) {
				ini.Put_SourceType(name, "Edge", p->Control.Edge);
			}

			if (p->Control.MaxUnit > 0 && p->Control.MaxUnit != control.MaxUnit) {
				ini.Put_Int(name, "MaxUnit", p->Control.MaxUnit);
			}

			if (p->Control.MaxInfantry > 0 && p->Control.MaxInfantry != control.MaxInfantry) {
				ini.Put_Int(name, "MaxInfantry", p->Control.MaxInfantry);
			}

			if (p->Control.MaxBuilding > 0 && p->Control.MaxBuilding != control.MaxBuilding) {
				ini.Put_Int(name, "MaxBuilding", p->Control.MaxBuilding);
			}

			if (p->Control.MaxVessel > 0 && p->Control.MaxVessel != control.MaxVessel) {
				ini.Put_Int(name, "MaxVessel", p->Control.MaxVessel);
			}

			if (p->Control.TechLevel != control.TechLevel) {
				ini.Put_Int(name, "TechLevel", p->Control.TechLevel);
			}

			if (p->Control.IQ != control.IQ) {
				ini.Put_Int(name, "IQ", p->Control.IQ);
			}

			if (p->IsPlayerControl != false && p != PlayerPtr) {
				ini.Put_Bool(name, "PlayerControl", p->IsPlayerControl);
			}

			ini.Put_Owners(name, "Allies", p->Control.Allies & ~((1 << p->Class->House) | (1 << HOUSE_NEUTRAL)));
		}
	}
}


/***********************************************************************************************
 * HouseClass::Is_No_YakMig -- Determines if no more yaks or migs should be allowed.           *
 *                                                                                             *
 *    This routine will examine the current yak and mig situation verses airfields. If there   *
 *    are equal aircraft to airfields, then this routine will return TRUE.                     *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  bool; Are all airfields full and thus no more yaks or migs are allowed?            *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/23/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Is_No_YakMig(void) const
{
	int quantity = AQuantity[AIRCRAFT_YAK] + AQuantity[AIRCRAFT_MIG];

	/*
	**	Adjust the quantity down one if there is an aircraft in production. This will
	**	allow production to resume after being held.
	*/
	FactoryClass const * factory = Fetch_Factory(RTTI_AIRCRAFT);
	if (factory != NULL && factory->Get_Object() != NULL) {
		AircraftClass const * air = (AircraftClass const *)factory->Get_Object();
		if (*air == AIRCRAFT_MIG || *air == AIRCRAFT_YAK) {
			quantity -= 1;
		}
	}

	if (quantity >= BQuantity[STRUCT_AIRSTRIP]) {
		return(true);
	}
	return(false);
}


/***********************************************************************************************
 * HouseClass::Is_Hack_Prevented -- Is production of the specified type and id prohibted?      *
 *                                                                                             *
 *    This is a special hack check routine to see if the object type and id specified is       *
 *    prevented from being produced. The Yak and the Mig are so prevented if there would be    *
 *    insufficient airfields for them to land upon.                                            *
 *                                                                                             *
 * INPUT:   rtti  -- The RTTI type of the value specified.                                     *
 *                                                                                             *
 *          value -- The type number (according to the RTTI type specified).                   *
 *                                                                                             *
 * OUTPUT:  bool; Is production of this object prohibited?                                     *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/23/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Is_Hack_Prevented(RTTIType rtti, int value) const
{
	if (rtti == RTTI_AIRCRAFTTYPE && (value == AIRCRAFT_MIG || value == AIRCRAFT_YAK)) {
		return(Is_No_YakMig());
	}
	return(false);
}


/***********************************************************************************************
 * HouseClass::Fire_Sale -- Cause all buildings to be sold.                                    *
 *                                                                                             *
 *    This routine will sell back all buildings owned by this house.                           *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  bool; Was a fire sale performed?                                                   *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/23/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Fire_Sale(void)
{
	if (CurBuildings > 0) {
		for (int index = 0; index < Buildings.Count(); index++) {
			BuildingClass * b = Buildings.Ptr(index);

			if (b != NULL && !b->IsInLimbo && b->House == this && b->Strength > 0) {
				b->Sell_Back(1);
			}
		}
		return(true);
	}
	return(false);
}


/***********************************************************************************************
 * HouseClass::Do_All_To_Hunt -- Send all units to hunt.                                       *
 *                                                                                             *
 *    This routine will cause all combatants of this house to go into hunt mode. The effect of *
 *    this is to throw everything this house has to muster at the enemies of this house.       *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/23/1996 JLB : Created.                                                                 *
 *   10/02/1996 JLB : Handles aircraft too.                                                    *
 *=============================================================================================*/
void HouseClass::Do_All_To_Hunt(void) const
{
	int index;

	for (index = 0; index < Units.Count(); index++) {
		UnitClass * unit = Units.Ptr(index);

		if (unit->House == this && unit->IsDown && !unit->IsInLimbo) {
			if (unit->Team) unit->Team->Remove(unit);
			unit->Assign_Mission(MISSION_HUNT);
		}
	}

	for (index = 0; index < Infantry.Count(); index++) {
		InfantryClass * infantry = Infantry.Ptr(index);

		if (infantry->House == this && infantry->IsDown && !infantry->IsInLimbo) {
			if (infantry->Team) infantry->Team->Remove(infantry);
			infantry->Assign_Mission(MISSION_HUNT);
		}
	}

	for (index = 0; index < Vessels.Count(); index++) {
		VesselClass * vessel = Vessels.Ptr(index);

		if (vessel->House == this && vessel->IsDown && !vessel->IsInLimbo) {
			if (vessel->Team) vessel->Team->Remove(vessel);
			vessel->Assign_Mission(MISSION_HUNT);
		}
	}

	for (index = 0; index < Aircraft.Count(); index++) {
		AircraftClass * aircraft = Aircraft.Ptr(index);

		if (aircraft->House == this && aircraft->IsDown && !aircraft->IsInLimbo) {
			if (aircraft->Team) aircraft->Team->Remove(aircraft);
			aircraft->Assign_Mission(MISSION_HUNT);
		}
	}
}


/***********************************************************************************************
 * HouseClass::Is_Allowed_To_Ally -- Determines if this house is allied to make allies.        *
 *                                                                                             *
 *    Use this routine to determine if this house is legally allowed to ally with the          *
 *    house specified. There are many reason why an alliance is not allowed. Typically, this   *
 *    is when there would be no more opponents left to fight or if this house has been         *
 *    defeated.                                                                                *
 *                                                                                             *
 * INPUT:   house -- The house that alliance with is desired.                                  *
 *                                                                                             *
 * OUTPUT:  bool; Is alliance with the house specified prohibited?                             *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/23/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
bool HouseClass::Is_Allowed_To_Ally(HousesType house) const
{
	/*
	**	Is not allowed to ally with a house that is patently invalid, such
	**	as one that is illegally defined.
	*/
	if (house == HOUSE_NONE) {
		return(false);
	}

	/*
	**	One cannot ally twice with the same house.
	*/
	if (Is_Ally(house)) {
		return(false);
	}

	/*
	**	If the scenario is being set up, then alliances are always
	**	allowed. No further checking is required.
	*/
	if (ScenarioInit) {
		return(true);
	}

	/*
	**	Alliances (outside of scneario init time) are allowed only if
	**	this is a multiplayer game. Otherwise, they are prohibited.
	*/
	if (Session.Type == GAME_NORMAL) {
		return(false);
	}

	/*
	**	When the house is defeated, it can no longer make alliances.
	*/
	if (IsDefeated) {
		return(false);
	}

#ifdef FIXIT_VERSION_3
	// Fix to prevent ally with computer.
	if ( !HouseClass::As_Pointer(house)->IsHuman) {
		return(false);
	}
#else	//	FIXIT_VERSION_3
#ifdef FIXIT_NO_COMP_ALLY
	// Fix to prevent ally with computer.
	if (PlayingAgainstVersion > VERSION_RED_ALERT_104 && !HouseClass::As_Pointer(house)->IsHuman) {
		return(false);
	}
#endif
#endif	//	FIXIT_VERSION_3

	/*
	**	Count the number of active houses in the game as well as the
	**	number of existing allies with this house.
	*/
	int housecount = 0;
	int allycount = 0;
	for (HousesType house2 = HOUSE_MULTI1; house2 < HOUSE_COUNT; house2++) {
		HouseClass * hptr = HouseClass::As_Pointer(house2);
		if (hptr != NULL && hptr->IsActive && !hptr->IsDefeated) {
			housecount++;
			if (Is_Ally(hptr)) {
				allycount++;
			}
		}
	}

	/*
	**	Alliance is not allowed if there wouldn't be any enemies left to
	**	fight.
	*/
	if (housecount == allycount+1) {
		return(false);
	}

	return(true);
}


/***********************************************************************************************
 * HouseClass::Computer_Paranoid -- Cause the computer players to becom paranoid.              *
 *                                                                                             *
 *    This routine will cause the computer players to become suspicious of the human           *
 *    players and thus the computer players will band together in order to defeat the          *
 *    human players.                                                                           *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   09/23/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Computer_Paranoid(void)
{

	/*
	**	Loop through every computer controlled house and make allies with all other computer
	**	controlled houses and then make enemies with all other human controlled houses.
	*/
	for (HousesType house = HOUSE_MULTI1; house < HOUSE_COUNT; house++) {
		HouseClass * hptr = HouseClass::As_Pointer(house);
		if (hptr != NULL && hptr->IsActive && !hptr->IsDefeated && !hptr->IsHuman) {
			hptr->IsParanoid = true;

			/*
			**	Break alliance with every human it is allied with and make friends with
			**	any other computer players.
			*/
			for (HousesType house2 = HOUSE_MULTI1; house2 < HOUSE_COUNT; house2++) {
				HouseClass * hptr2 = HouseClass::As_Pointer(house2);
				if (hptr2 != NULL && hptr2->IsActive && !hptr2->IsDefeated) {
					if (hptr2->IsHuman) {
						hptr->Make_Enemy(house2);
					} else {
						hptr->Make_Ally(house2);
					}
				}
			}
		}
	}
}


/***********************************************************************************************
 * HouseClass::Adjust_Power -- Adjust the power value of the house.                            *
 *                                                                                             *
 *    This routine will update the power output value of the house. It will cause any buildgins*
 *    that need to be redrawn to do so.                                                        *
 *                                                                                             *
 * INPUT:   adjust   -- The amount to adjust the power output value.                           *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   11/01/1996 BWG : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Adjust_Power(int adjust)
{
	Power += adjust;

	Update_Spied_Power_Plants();
}


/***********************************************************************************************
 * HouseClass::Adjust_Drain -- Adjust the power drain value of the house.                      *
 *                                                                                             *
 *    This routine will update the drain value of the house. It will cause any buildings that  *
 *    need to be redraw to do so.                                                              *
 *                                                                                             *
 * INPUT:   adjust   -- The amount to adjust the drain (positive means more drain).            *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   11/01/1996 BWG : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Adjust_Drain(int adjust)
{
	Drain += adjust;
	Update_Spied_Power_Plants();
}


/***********************************************************************************************
 * HouseClass::Update_Spied_Power_Plants -- Redraw power graphs on spied-upon power plants.    *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/11/1996 BWG : Created.                                                                 *
 *=============================================================================================*/
void HouseClass::Update_Spied_Power_Plants(void)
{
	int count = CurrentObject.Count();
	if (count) {
		for (int index = 0; index < count; index++) {
			ObjectClass const * tech = CurrentObject[index];
			if (tech && tech->What_Am_I()==RTTI_BUILDING) {
				BuildingClass *bldg = (BuildingClass *)tech;
				if (!bldg->IsOwnedByPlayer && *bldg == STRUCT_POWER || *bldg == STRUCT_ADVANCED_POWER) {
					if ( bldg->SpiedBy & (1<<(PlayerPtr->Class->House)) ) {
						bldg->Mark(MARK_CHANGE);
					}
				}
			}
		}
	}
}


/***********************************************************************************************
 * HouseClass::Find_Cell_In_Zone -- Finds a legal placement cell within the zone.              *
 *                                                                                             *
 *    Use this routine to determine where the specified object should go if it were to go      *
 *    some random (but legal) location within the zone specified.                              *
 *                                                                                             *
 * INPUT:   techno   -- The object that is desirous of going into the zone specified.          *
 *                                                                                             *
 *          zone     -- The zone to find a location within.                                    *
 *                                                                                             *
 * OUTPUT:  Returns with the cell that the specified object could be placed in the zone. If    *
 *          no valid location could be found, then 0 is returned.                              *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   11/01/1996 JLB : Created.                                                                 *
 *   11/04/1996 JLB : Not so strict on zone requirement.                                       *
 *=============================================================================================*/
CELL HouseClass::Find_Cell_In_Zone(TechnoClass const * techno, ZoneType zone) const
{
	if (techno == NULL) return(0);

	int bestval = -1;
	int bestcell = 0;
	TechnoTypeClass const * ttype = techno->Techno_Type_Class();

	/*
	**	Pick a random location within the zone specified.
	*/
	CELL trycell = Random_Cell_In_Zone(zone);

	short const * list = NULL;
	if (techno->What_Am_I() == RTTI_BUILDING) {
		list = techno->Occupy_List(true);
	}

	/*
	**	Find a legal placement position as close as possible to the picked location while still
	**	remaining within the zone.
	*/
	for (CELL cell = 0; cell < MAP_CELL_TOTAL; cell++) {
//		if (Map.In_Radar(cell)) {
		if (Map.In_Radar(cell) && Which_Zone(cell) != ZONE_NONE) {
			bool ok = ttype->Legal_Placement(cell);

			/*
			**	Another (adjacency) check is required for buildings.
			*/
			if (ok && list != NULL && !Map.Passes_Proximity_Check(ttype, techno->House->Class->House, list, cell)) {
				ok = false;
			}

			if (ok) {
				int dist = Distance(Cell_Coord(cell), Cell_Coord(trycell));
				if (bestval == -1 || dist < bestval) {
					bestval = dist;
					bestcell = cell;
				}
			}
		}
	}

	/*
	**	Return the best location to move to.
	*/
	return(bestcell);
}


/***********************************************************************************************
 * HouseClass::Random_Cell_In_Zone -- Find a (technically) legal cell in the zone specified.   *
 *                                                                                             *
 *    This routine will pick a random cell within the zone specified. The pick will be         *
 *    clipped to the map edge when necessary.                                                  *
 *                                                                                             *
 * INPUT:   zone  -- The zone to pick a cell from.                                             *
 *                                                                                             *
 * OUTPUT:  Returns with a picked cell within the zone. If the entire zone lies outside of the *
 *          map, then a cell in the core zone is returned instead.                             *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   11/04/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
CELL HouseClass::Random_Cell_In_Zone(ZoneType zone) const
{
	COORDINATE coord = 0;
	int maxdist = 0;
	switch (zone) {
		case ZONE_CORE:
			coord = Coord_Scatter(Center, Random_Pick(0, Radius), true);
			break;

		case ZONE_NORTH:
			maxdist = min(Radius*3, (Coord_Y(Center) - Cell_To_Lepton(Map.MapCellY)) - CELL_LEPTON_H);
			if (maxdist < 0) break;
			coord = Coord_Move(Center, (DirType)(Random_Pick(DIR_N, DIR_E)-((DirType)32)), Random_Pick(min(Radius*2, maxdist), min(Radius*3, maxdist)));
			break;

		case ZONE_EAST:
			maxdist = min(Radius*3, (Cell_To_Lepton(Map.MapCellX + Map.MapCellWidth) - Coord_X(Center)) - CELL_LEPTON_W);
			if (maxdist < 0) break;
			coord = Coord_Move(Center, Random_Pick(DIR_NE, DIR_SE), Random_Pick(min(Radius*2, maxdist), min(Radius*3, maxdist)));
			break;

		case ZONE_SOUTH:
			maxdist = min(Radius*3, (Cell_To_Lepton(Map.MapCellY + Map.MapCellHeight) - Coord_Y(Center)) - CELL_LEPTON_H);
			if (maxdist < 0) break;
			coord = Coord_Move(Center, Random_Pick(DIR_SE, DIR_SW), Random_Pick(min(Radius*2, maxdist), min(Radius*3, maxdist)));
			break;

		case ZONE_WEST:
			maxdist = min(Radius*3, (Coord_X(Center) - Cell_To_Lepton(Map.MapCellX)) - CELL_LEPTON_W);
			if (maxdist < 0) break;
			coord = Coord_Move(Center, Random_Pick(DIR_SW, DIR_NW), Random_Pick(min(Radius*2, maxdist), min(Radius*3, maxdist)));
			break;
	}

	/*
	**	Double check that the location is valid and if so, convert it into a cell
	**	number.
	*/
	CELL cell;
	if (coord == 0 || !Map.In_Radar(Coord_Cell(coord))) {
		if (zone == ZONE_CORE) {

			/*
			**	Finding a cell within the core failed, so just pick the center
			**	cell. This cell is guaranteed to be valid.
			*/
			cell = Coord_Cell(Center);
		} else {

			/*
			**	If the edge fails, then try to find a cell within the core.
			*/
			cell = Random_Cell_In_Zone(ZONE_CORE);
		}
	} else {
		cell = Coord_Cell(coord);
	}

	/*
	**	If the randomly picked location is not in the legal map area, then clip it to
	**	the legal map area.
	*/
	if (!Map.In_Radar(cell)) {
		int x = Cell_X(cell);
		int y = Cell_Y(cell);

		if (x < Map.MapCellX) x = Map.MapCellX;
		if (y < Map.MapCellY) y = Map.MapCellY;
		if (x >= Map.MapCellX + Map.MapCellWidth) x = Map.MapCellX + Map.MapCellWidth -1;
		if (y >= Map.MapCellY + Map.MapCellHeight) y = Map.MapCellY + Map.MapCellHeight -1;
		cell = XY_Cell(x, y);
	}
	return(cell);
}