CnC_Remastered_Collection

BUILDING.CPP (224993B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
 // software: you can redistribute it and/or modify it under the terms of 
 // the GNU General Public License as published by the Free Software Foundation, 
 // either version 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 /* $Header:   F:\projects\c&c\vcs\code\building.cpv   2.13   02 Aug 1995 17:00:14   JOE_BOSTIC  $ */
 /***********************************************************************************************
  ***             C O N F I D E N T I A L  ---  W E S T W O O D   S T U D I O S               ***
  ***********************************************************************************************
  *                                                                                             *
  *                 Project Name : Command & Conquer                                            *
  *                                                                                             *
  *                    File Name : BUILDING.CPP                                                 *
  *                                                                                             *
  *                   Programmer : Joe L. Bostic                                                *
  *                                                                                             *
  *                   Start Date : September 10, 1993                                           *
  *                                                                                             *
  *                  Last Update : August 20, 1995 [JLB]                                        *
  *                                                                                             *
  *---------------------------------------------------------------------------------------------*
  * Functions:                                                                                  *
  *   BuildingClass::AI -- Handles non-graphic AI processing for buildings.                     *
  *   BuildingClass::Active_Click_With -- Handles cell selection for buildings.                 *
  *   BuildingClass::As_Target -- Convert the building into a target value.                     *
  *   BuildingClass::Assign_Target -- Assigns a target to the building.                         *
  *   BuildingClass::Begin_Mode -- Begins an animation mode for the building.                   *
  *   BuildingClass::BuildingClass -- Constructor for buildings.                                *
  *   BuildingClass::Can_Demolish -- Can the player demolish (sell back) the building?          *
  *   BuildingClass::Can_Enter_Cell -- Determines if building can be placed down.               *
  *   BuildingClass::Can_Fire -- Determines if this building can fire.                          *
  *   BuildingClass::Captured -- Captures the building.                                         *
  *   BuildingClass::Center_Coord -- Fetches the center coordinate for the building.            *
  *   BuildingClass::Click_With -- Handles clicking on the map while the building is selected.  *
  *   BuildingClass::Crew_Type -- This determines the crew that this object generates.          *
  *   BuildingClass::Death_Announcement -- Announce the death of this building.                 *
  *   BuildingClass::Debug_Dump -- Displays building status to the monochrome screen.           *
  *   BuildingClass::Detach -- Handles target removal from the game system.                     *
  *   BuildingClass::Detach_All -- Possibly abandons production according to factory type.      *
  *   BuildingClass::Draw_It -- Displays the building at the location specified.                *
  *   BuildingClass::Drop_Debris -- Drops rubble when building is destroyed.                    *
  *   BuildingClass::Enter_Idle_Mode -- The building will enter its idle mode.                  *
  *   BuildingClass::Exit_Object -- Initiates an object to leave the building.                  *
  *   BuildingClass::Fire_At -- Fires weapon at specified target.                               *
  *   BuildingClass::Fire_Coord -- Calculates the coordinate that projectile would appear.      *
  *   BuildingClass::Fire_Direction -- Fetches the direction of firing.                         *
  *   BuildingClass::Fire_Out -- Handles when attached animation expires.                       *
  *   BuildingClass::Flush_For_Placement -- Handles clearing a zone for object placement.       *
  *   BuildingClass::Grand_Opening -- Handles construction completed special operations.        *
  *   BuildingClass::Greatest_Threat -- Searches for target that building can fire upon.        *
  *   BuildingClass::Init -- Initialize the building system to an empty null state.             *
  *   BuildingClass::Limbo -- Handles power adjustment as building goes into limbo.             *
  *   BuildingClass::Look -- Reveal map around building.                                        *
  *   BuildingClass::Mark -- Building interface to map rendering system.                        *
  *   BuildingClass::Mission_Attack -- Handles attack mission for building.                     *
  *   BuildingClass::Mission_Construction -- Handles mission construction.                      *
  *   BuildingClass::Mission_Deconstruction -- Handles building deconstruction.                 *
  *   BuildingClass::Mission_Guard -- Handles guard mission for combat buildings.               *
  *   BuildingClass::Mission_Harvest -- Handles refinery unloading harvesters.                  *
  *   BuildingClass::Mission_Missile -- State machine for nuclear missile launch.               *
  *   BuildingClass::Mission_Repair -- Handles the repair (active) state for building.          *
  *   BuildingClass::Mission_Unload -- Handles the unload mission for a building.               *
  *   BuildingClass::Pip_Count -- Determines "full" pips to display for building.               *
  *   BuildingClass::Power_Output -- Fetches the current power output from this building.       *
  *   BuildingClass::Read_INI -- Reads buildings from INI file.                                 *
  *   BuildingClass::Receive_Message -- Handle an incoming message to the building.             *
  *   BuildingClass::Refund_Amount -- Fetches the refund amount if building is sold.            *
  *   BuildingClass::Remap_Table -- Fetches the remap table to use for this building.           *
  *   BuildingClass::Repair -- Initiates or terminates the repair process.                      *
  *   BuildingClass::Revealed -- Reveals the building to the specified house.                   *
  *   BuildingClass::Sell_Back -- Controls the sell back (demolish) operation.                  *
  *   BuildingClass::Sort_Y -- Returns the building coordinate used for sorting.                *
  *   BuildingClass::Take_Damage -- Inflicts damage points upon a building.                     *
  *   BuildingClass::Toggle_Primary -- Toggles the primary factory state.                       *
  *   BuildingClass::Unlimbo -- Removes a building from limbo state.                            *
  *   BuildingClass::Update_Buildables -- Informs sidebar of additional construction options.   *
  *   BuildingClass::Update_Specials -- removes computer specials for lost bld                  *
  *   BuildingClass::What_Action -- Determines action to perform if click on specified object.  *
  *   BuildingClass::What_Action -- Determines what action will occur.                          *
  *   BuildingClass::Write_INI -- Writes all building data to an INI file.                      *
  *   BuildingClass::delete -- Deallocates building object.                                     *
  *   BuildingClass::new -- Allocates a building object from building pool.                     *
  *   BuildingClass::~BuildingClass -- Destructor for building type objects.                    *
  *   BuildingClass::Validate -- validates building pointer												  *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 #include	"function.h"
 
 /*
 ** New sidebar for GlyphX multiplayer. ST - 3/26/2019 12:24PM
 */
 #include "SidebarGlyphx.h"
 
 
 enum SAMState {
 	SAM_NONE=-1,					// Used for non SAM site buildings.
 	SAM_UNDERGROUND,			// Launcher is underground and awaiting orders.
 	SAM_RISING,					// Doors open and launcher rises to normal locked down position.
 	SAM_READY,					// Launcher can be facing any direction tracking targets.
 	SAM_FIRING,					// Stationary while missile is being fired.
 	SAM_READY2,					// Launcher can be facing any direction tracking targets.
 	SAM_FIRING2,				// Stationary while missile is being fired.
 	SAM_LOCKING,				// Rotating to locked position in preparation for lowering.
 	SAM_LOWERING,				// Launcher is lowering into the ground.
 };
 
 
 /***************************************************************************
 **	Center of building offset table.
 */
 COORDINATE const BuildingClass::CenterOffset[BSIZE_COUNT] = {
 	0x00800080L,
 	0x008000FFL,
 	0x00FF0080L,
 	0x00FF00FFL,
 	0x018000FFL,
 	0x00FF0180L,
 	0x01800180L,
 
 	0x00FF0200L,
 
 	0x02800280L,
 };
 
 /*
 ** This contains the value of the Virtual Function Table Pointer
 */
 void * BuildingClass::VTable;
 
 
 /***********************************************************************************************
  * BuildingClass::Validate -- validates building pointer													  *
  *                                                                                             *
  * INPUT:                                                                                      *
  *		none.																												  *
  *                                                                                             *
  * OUTPUT:                                                                                     *
  *		1 = ok, 0 = error																								  *
  *                                                                                             *
  * WARNINGS:                                                                                   *
  *		none.																												  *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   08/09/1995 BRR : Created.                                                                 *
  *=============================================================================================*/
 #ifdef CHEAT_KEYS
 int BuildingClass::Validate(void) const
 {
 	int num;
 
 	num = Buildings.ID(this);
 	if (num < 0 || num >= BUILDING_MAX) {
 		Validate_Error("BUILDING");
 		return (0);
 	}
 	else
 		return (1);
 }
 #else
 #define	Validate()
 #endif
 
 
 /***********************************************************************************************
  * BuildingClass::Receive_Message -- Handle an incoming message to the building.               *
  *                                                                                             *
  *    This routine handles an incoming message to the building. Messages regulate the          *
  *    various cooperative ventures between buildings and units. This might include such        *
  *    actions as coordinating the construction yard animation with the actual building's       *
  *    construction animation.                                                                  *
  *                                                                                             *
  * INPUT:   from     -- The originator of the message received.                                *
  *                                                                                             *
  *          message  -- The radio message received.                                            *
  *                                                                                             *
  *          param    -- Reference to an optional parameter that might be used to return        *
  *                      extra information to the message originator.                           *
  *                                                                                             *
  * OUTPUT:  Returns with the response to the message (typically, this is just RADIO_OK).       *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/09/1994 JLB : Created.                                                                 *
  *   06/26/1995 JLB : Forces refinery load anim to start immediately.                          *
  *   08/13/1995 JLB : Uses ScenarioInit for special loose "CAN_LOAD" check.                    *
  *=============================================================================================*/
 RadioMessageType BuildingClass::Receive_Message(RadioClass * from, RadioMessageType message, long & param)
 {
 	Validate();
 	switch (message) {
 
 		/*
 		**	This message is received as a request to attach/load/dock with this building.
 		**	Verify that this is allowed and return the appropriate response.
 		*/
 		case RADIO_HELLO:
 			//Refineries can't be interupted while they're processing a harvester - LLL April 22, 2020
 			if (Mission == MISSION_HARVEST) {
 				return(RADIO_NEGATIVE);
 			}
 			break;
 
 		case RADIO_CAN_LOAD:
 			TechnoClass::Receive_Message(from, message, param);
 			if (BState == BSTATE_CONSTRUCTION || (!ScenarioInit && Class->Type != STRUCT_REFINERY && In_Radio_Contact())) return(RADIO_NEGATIVE);
 			switch (Class->Type) {
 				case STRUCT_AIRSTRIP:
 					if (from->What_Am_I() == RTTI_AIRCRAFT && *((AircraftClass const *)from) == AIRCRAFT_CARGO) {
 						return(RADIO_ROGER);
 					}
 					break;
 
 				case STRUCT_HELIPAD:
 					if (from->What_Am_I() == RTTI_AIRCRAFT && !((AircraftClass const *)from)->Class->IsFixedWing) {
 						return(RADIO_ROGER);
 					}
 					break;
 
 				case STRUCT_REPAIR:
 					if (/*from->Health_Ratio() < 0x0100 &&*/ from->What_Am_I() == RTTI_UNIT || from->What_Am_I() == RTTI_AIRCRAFT) {
 						return(RADIO_ROGER);
 					}
 					return(RADIO_NEGATIVE);
 
 				case STRUCT_REFINERY:
 					if (from->What_Am_I() == RTTI_UNIT &&
 						*((UnitClass *)from) == UNIT_HARVESTER &&
 						(ScenarioInit || !Is_Something_Attached())) {
 
 						return((Contact_With_Whom() != from) ? RADIO_ROGER : RADIO_NEGATIVE);
 					}
 					break;
 
 				default:
 					break;
 			}
 			return(RADIO_NEGATIVE);
 
 		/*
 		**	This message is received when the object has attached itself to this
 		**	building.
 		*/
 		case RADIO_IM_IN:
 			if (Mission == MISSION_DECONSTRUCTION) {
 				return(RADIO_NEGATIVE);
 			}
 			switch (Class->Type) {
 				case STRUCT_REPAIR:
 					IsReadyToCommence = true;
 					Assign_Mission(MISSION_REPAIR);
 					from->Assign_Mission(MISSION_SLEEP);
 					return(RADIO_ROGER);
 
 				case STRUCT_HELIPAD:
 					Assign_Mission(MISSION_REPAIR);
 					from->Assign_Mission(MISSION_SLEEP);
 					return(RADIO_ROGER);
 
 				case STRUCT_REFINERY:
 					ScenarioInit++;
 					Begin_Mode(BSTATE_ACTIVE);
 					ScenarioInit--;
 					Mark(MARK_CHANGE);
 					Assign_Mission(MISSION_HARVEST);
 					return(RADIO_ATTACH);
 			}
 			break;
 
 		/*
 		**	Docking maneuver maintenance message. See if new order should be given to the
 		**	unit trying to dock.
 		*/
 		case RADIO_DOCKING:
 			TechnoClass::Receive_Message(from, message, param);
 
 			/*
 			**	When in radio contact for loading, the refinery starts
 			**	flashing the lights.
 			*/
 			//Fix for refinery animation bug when mission is harvest - LLL April 22, 2020
 			if (*this == STRUCT_REFINERY && BState != BSTATE_FULL && Mission != MISSION_HARVEST) {
 				Begin_Mode(BSTATE_FULL);
 			}
 
 			/*
 			**	If this building is already in radio contact, then it might
 			**	be able to satisfy the request to load by bumping off any
 			**	preoccupying task.
 			*/
 			if (*this == STRUCT_REPAIR) {
 				if (Contact_With_Whom() != from) {
 					if (Transmit_Message(RADIO_ON_DEPOT) == RADIO_ROGER) {
 						if (Transmit_Message(RADIO_NEED_REPAIR) == RADIO_NEGATIVE) {
 							Transmit_Message(RADIO_RUN_AWAY);
 							Transmit_Message(RADIO_OVER_OUT);
 							return(RADIO_ROGER);
 						}
 					}
 				}
 			}
 
 			/*
 			**	Establish contact with the object if this building isn't already in contact
 			**	with another.
 			*/
 			if (!In_Radio_Contact()) {
 				Transmit_Message(RADIO_HELLO, from);
 			}
 
 			if (Transmit_Message(RADIO_NEED_TO_MOVE) == RADIO_ROGER) {
 				if (*this == STRUCT_HELIPAD) {
 					param = As_Target();
 				} else {
 					if (*this == STRUCT_REPAIR) {
 						Transmit_Message(RADIO_TETHER);
 						param = ::As_Target(Coord_Cell(Center_Coord()));
 					} else {
 						param = ::As_Target(Coord_Cell(Adjacent_Cell(Center_Coord(), DIR_SW)));
 					}
 				}
 
 				/*
 				**	Tell the harvester to move to the docking pad of the refinery.
 				*/
 				if (Transmit_Message(RADIO_MOVE_HERE, param) == RADIO_YEA_NOW_WHAT) {
 
 					/*
 					**	Since the harvester is already there, tell it to begin the backup
 					**	procedure now. If it can't, then tell it to get outta here.
 					*/
 					Transmit_Message(RADIO_TETHER);
 					if (*this == STRUCT_REFINERY && Transmit_Message(RADIO_BACKUP_NOW, from) != RADIO_ROGER) {
 						from->Scatter(NULL, true);
 					}
 				}
 			}
 			return(RADIO_ROGER);
 
 		/*
 		**	If a transport or harvester is requesting permission to head toward, dock
 		**	and load/unload, check to make sure that this is allowed given the current
 		**	state of the building.
 		*/
 		case RADIO_ARE_REFINERY:
 			if (Is_Something_Attached() || In_Radio_Contact() || IsInLimbo || House->Class->House != from->Owner() || (*this != STRUCT_REFINERY/* && *this != STRUCT_REPAIR*/)) {
 				return(RADIO_NEGATIVE);
 			}
 			return(RADIO_ROGER);
 
 		/*
 		**	Someone is telling us that it is starting construction. This should only
 		**	occur if this is a construction yard and a building was just placed on
 		**	the map.
 		*/
 		case RADIO_BUILDING:
 			Assign_Mission(MISSION_REPAIR);
 			TechnoClass::Receive_Message(from, message, param);
 			return(RADIO_ROGER);
 
 		/*
 		**	Someone is telling us that they have finished construction. This should
 		**	only occur if this is a construction yard and the building that was being
 		**	constructed has finished. In this case, stop the construction yard
 		**	animation.
 		*/
 		case RADIO_COMPLETE:
 			if (Mission != MISSION_DECONSTRUCTION) {
 				Assign_Mission(MISSION_GUARD);
 			}
 			TechnoClass::Receive_Message(from, message, param);
 			return(RADIO_ROGER);
 
 		/*
 		**	This message may occur unexpectedly if the unit in contact with this
 		**	building is suddenly destroyed. Handle any cleanup necessary. For example,
 		**	a construction yard should stop its construction animation in this case.
 		*/
 		case RADIO_OVER_OUT:
 			Begin_Mode(BSTATE_IDLE);
 			TechnoClass::Receive_Message(from, message, param);
 			return(RADIO_ROGER);
 
 		/*
 		**	This message is received when an object has completely left
 		** building. Sometimes special cleanup action is required when
 		**	this event occurs.
 		*/
 		case RADIO_UNLOADED:
 			if (*this == STRUCT_REPAIR) {
 				if (Distance(from) < 0x0180) {
 					return(RADIO_ROGER);
 				}
 			}
 
 			//Turn off the refinery lights - LLL April 22, 2020
 			if (*this == STRUCT_REFINERY) {
 				Begin_Mode(BSTATE_IDLE);
 			}
 
 			TechnoClass::Receive_Message(from, message, param);
 			if (*this == STRUCT_WEAP || *this == STRUCT_AIRSTRIP || *this == STRUCT_REPAIR) return(RADIO_RUN_AWAY);
 			return(RADIO_ROGER);
 	}
 
 	/*
 	**	Pass along the message to the default message handler in the radio itself.
 	*/
 	return(TechnoClass::Receive_Message(from, message, param));
 }
 
 
 #ifdef CHEAT_KEYS
 /***********************************************************************************************
  * BuildingClass::Debug_Dump -- Displays building status to the monochrome screen.             *
  *                                                                                             *
  *    This utility function will output the current status of the building class to the        *
  *    monochrome screen. It is through this data that bugs may be fixed or detected.           *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   05/31/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Debug_Dump(MonoClass *mono) const
 {
 	Validate();
 	mono->Set_Cursor(0, 0);
 	mono->Print(
 		"ÚName:ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂMission:ÄÄÄÂTarCom:ÂÄÄÄÄÄÄÄÂRadio:ÂCoord:ÄÄÂÄÄÄÄÄÄÄÄÂSt:Ä¿\n"
 		"³                   ³           ³       ³       ³      ³        ³        ³    ³\n"
 		"ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂNÂYÂHealth:ÄÂÄÄÄÁÄÂTurret:ÂÄÄÄÄÄÁÂÄBuilding:ÄÄÂCargo:ÄÄÄÄÁÄÄÄÄ´\n"
 		"³Active........³ ³ ³        ³     ³       ³      ³            ³               ³\n"
 		"³Limbo.........³ ³ ÃÄÄÄÄÄÄÄÄÁÄÄÄÄÄÁÄÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´\n"
 		"³Owned.........³ ³ ³Last Message:                                             ³\n"
 		"³Discovered....³ ³ ÃTimer:ÂArm:ÂÄÄÄÄÄÄÂTiberium:ÂFlash:ÂStage:ÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ\n"
 		"³Selected......³ ³ ³      ³    ³      ³         ³      ³      ³                \n"
 		"³Teathered.....³ ³ ÃÄÄÄÄÄÄÁÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÙ                \n"
 		"³Locked on Map.³ ³ ³                                                           \n"
 		"³Is A Loaner...³ ³ ³                                                           \n"
 		"³              ³ ³ ³                                                           \n"
 		"³              ³ ³ ³                                                           \n"
 		"³              ³ ³ ³                                                           \n"
 		"³Repairing.....³ ³ ³                                                           \n"
 		"³              ³ ³ ³                                                           \n"
 		"³              ³ ³ ³                                                           \n"
 		"³Recoiling.....³ ³ ³                                                           \n"
 		"³To Display....³ ³ ³                                                           \n"
 		"ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÁÄÙ                                                           \n");
 	mono->Set_Cursor(1, 1);mono->Printf("%s:%s", House->Class->IniName, Class->IniName);
 	mono->Set_Cursor(35, 3);mono->Printf("%02X:%02X", PrimaryFacing.Current(), PrimaryFacing.Desired());
 	mono->Set_Cursor(50, 3);
 	if (Factory) {
 		mono->Printf(Factory->Get_Object()->Class_Of().IniName);
 		mono->Printf(" ");
 		mono->Printf("%d%%", Factory->Completion());
 	} else {
 		mono->Printf("(empty)");
 	}
 
 	mono->Text_Print("X", 16 + (IsRepairing?2:0), 14);
 //	mono->Set_Cursor(44, 3);mono->Printf("%d", SAM);
 	mono->Set_Cursor(34, 1);mono->Printf("%04X", TarCom);
 	mono->Set_Cursor(28, 7);mono->Printf("%2d", Arm);
 
 	TechnoClass::Debug_Dump(mono);
 }
 #endif
 
 
 /***********************************************************************************************
  * BuildingClass::Draw_It -- Displays the building at the location specified.                  *
  *                                                                                             *
  *    This is the low level graphic routine that displays the building at the location         *
  *    specified.                                                                               *
  *                                                                                             *
  * INPUT:   x,y   -- The coordinate to draw the building at.                                   *
  *                                                                                             *
  *          window   -- The clipping window to use.                                            *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/20/1994 JLB : Created.                                                                 *
  *   06/27/1994 JLB : Takes a clipping window parameter.                                       *
  *   07/06/1995 JLB : Handles damaged silos correctly.                                         *
  *=============================================================================================*/
 void BuildingClass::Draw_It(int x, int y, WindowNumberType window)
 {
 	Validate();
 	void const * shapefile;	// Pointer to loaded shape file.
 	int shapenum;
 
 	shapenum = Fetch_Stage();
 
 	/*
 	**	The shape file to use for rendering depends on whether the building
 	**	is undergoing construction or not.
 	*/
 	if (BState == BSTATE_CONSTRUCTION) {
 		shapefile = Class->Get_Buildup_Data();
 
 		/*
 		**	If the building is deconstructing, then the display frame progresses
 		**	from the end to the beginning. Reverse the shape number accordingly.
 		*/
 		if (Mission == MISSION_DECONSTRUCTION) {
 			shapenum = (Class->Anims[BState].Start+Class->Anims[BState].Count-1)-shapenum;
 		}
 
 	} else {
 
 		shapefile = Class->Get_Image_Data();
 
 		/*
 		**	The obelisk has a stage value than can be overridden by
 		**	its current state.
 		*/
 		if (*this == STRUCT_OBELISK) {
 			if (IsCharged) {
 				shapenum = 3;
 			} else {
 				if (IsCharging) {
 					shapenum = Fetch_Stage();
 				} else {
 					shapenum = 0;
 				}
 			}
 		}
 
 		/*
 		**	Buildings that contain a turret handle their shape determination
 		**	differently than normal buildings. They need to take into consideration
 		**	the direction the turret is facing.
 		*/
 		if (Class->IsTurretEquipped) {
 			shapenum = UnitClass::BodyShape[Facing_To_32(PrimaryFacing.Current())];
 
 			if (*this == STRUCT_SAM) {
 
 				/*
 				**	SAM sites that are free to rotate fetch their animation frame
 				**	from the building's turret facing. All other animation stages
 				**	fetch their frame from the embedded animation sequencer.
 				*/
 				if (Status == SAM_READY || Status == SAM_FIRING || Status == SAM_READY2 || Status == SAM_FIRING2 || Status == SAM_LOCKING) {
 					shapenum += 16;
 				} else {
 					shapenum = Fetch_Stage();
 				}
 			} else {
 				if (IsInRecoilState) {
 					shapenum += 32;
 				}
 			}
 			if (Health_Ratio() < 0x0080) {
 				shapenum += 64;
 			}
 		} else {
 
 			/*
 			**	If it has only one point of strength left, it is shown in the
 			**	worst state possible.
 			*/
 			if (Strength <= 1) {
 				shapenum = Get_Build_Frame_Count(shapefile)-1;
 			} else {
 
 				if (*this == STRUCT_WEAP) {
 					shapenum = 0;
 					if (Health_Ratio() < 0x0080) {
 						shapenum = 1;
 					}
 
 				} else {
 
 					/*
 					**	Special render stage for silos. The stage is dependant on the current
 					**	Tiberium collected as it relates to Tiberium capacity.
 					*/
 					if (*this == STRUCT_STORAGE) {
 						int level = 0;
 						if (House->Capacity) {
 							level = (House->Tiberium * 5) / House->Capacity;
 						}
 //						int level = Fixed_To_Cardinal(4, Cardinal_To_Fixed(House->Capacity, House->Tiberium));
 
 						shapenum += Bound(level, 0, 4);
 						if (Health_Ratio() < 0x0080) {
 							shapenum += 5;
 						}
 
 					} else {
 
 						if (Health_Ratio() < 0x0080) {
 
 							/*
 							**	Special damage stage for pump.
 							*/
 							if (!Class->IsSimpleDamage) {
 								int last1 = Class->Anims[BSTATE_IDLE].Start + Class->Anims[BSTATE_IDLE].Count;
 								int last2 = Class->Anims[BSTATE_ACTIVE].Start + Class->Anims[BSTATE_ACTIVE].Count;
 								int largest = MAX(last1, last2);
 								last2 = Class->Anims[BSTATE_AUX1].Start + Class->Anims[BSTATE_AUX1].Count;
 								largest = MAX(largest, last2);
 								last2 = Class->Anims[BSTATE_AUX2].Start + Class->Anims[BSTATE_AUX2].Count;
 								largest = MAX(largest, last2);
 
 								shapenum += largest;
 							} else {
 
 								/*
 								**	Presume that the damage stage is the end frame.
 								*/
 								shapenum = Get_Build_Frame_Count(shapefile) - 2;
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 
 	/*
 	**	Actually draw the building shape.
 	*/
 	IsTheaterShape = Class->IsTheater;
 	Techno_Draw_Object(shapefile, shapenum, x, y, window);
 	IsTheaterShape = false;
 
 	/*
 	** Patch for adding overlay onto weapon factory.  Only add the overlay if
 	** the building has more than 1 hp.  Also, if the building's in radio
 	** contact, he must be unloading a constructed vehicle, so draw that
 	** vehicle before drawing the overlay.
 	*/
 	if (BState != BSTATE_CONSTRUCTION) {
 
 		/*
 		**	A Tethered object is always rendered AFTER the building.
 		*/
 		if (*this == STRUCT_WEAP && IsTethered && In_Radio_Contact() && !Contact_With_Whom()->IsInLimbo) {
 			TechnoClass * contact = Contact_With_Whom();
 
 			assert(contact->IsActive);
 			int xxx = x + ((int)Lepton_To_Pixel((int)Coord_X(contact->Render_Coord())) - (int)Lepton_To_Pixel((int)Coord_X(Render_Coord())));
 			int yyy = y + ((int)Lepton_To_Pixel((int)Coord_Y(contact->Render_Coord())) - (int)Lepton_To_Pixel((int)Coord_Y(Render_Coord())));
 			contact->Draw_It(xxx, yyy, window);
 			contact->IsToDisplay = false;
 		}
 
 		/*
 		**	Draw the weapon factory custom overlay graphic.
 		*/
 		if (*this == STRUCT_WEAP && Strength > 1) {
 			shapenum = Door_Stage();
 			if (Health_Ratio() < 0x0080) shapenum += 10;
 			// Added override shape file name. ST - 6/20/2019 1:35PM
 			//Techno_Draw_Object(WarFactoryOverlay, shapenum, x, y, window);
 			Techno_Draw_Object_Virtual(WarFactoryOverlay, shapenum, x, y, window, "WEAP2");
 		}
 
 		/*
 		**	Draw any repair feedback graphic required.
 		*/
 		if (IsRepairing && IsWrenchVisible) {
 			CC_Draw_Shape(ObjectTypeClass::SelectShapes, SELECT_WRENCH, x, y, window, SHAPE_CENTER|SHAPE_WIN_REL);
 		}
 	}
 
 	TechnoClass::Draw_It(x, y, window);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Mark -- Building interface to map rendering system.                          *
  *                                                                                             *
  *    This routine is used to mark the map cells so that when it renders                       *
  *    the underlying icons will also be updated as necessary.                                  *
  *                                                                                             *
  * INPUT:   mark  -- Type of image change (MARK_UP, _DOWN, _CHANGE)                            *
  *             MARK_UP  -- Building is removed.                                                *
  *             MARK_CHANGE -- Building changes shape.                                          *
  *             MARK_DOWN -- Building is added.                                                 *
  *                                                                                             *
  * OUTPUT:  bool; Did the mark operation succeed? Failure could be the result of marking down  *
  *                when the building is already marked down, or visa versa.                     *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   03/31/1994 JLB : Created.                                                                 *
  *   04/15/1994 JLB : Converted to member function.                                            *
  *   04/16/1994 JLB : Added health bar tracking.                                               *
  *   12/23/1994 JLB : Calls low level check before proceeding.                                 *
  *   01/27/1995 JLB : Special road spacer template added.                                      *
  *=============================================================================================*/
 bool BuildingClass::Mark(MarkType mark)
 {
 	Validate();
 	if (TechnoClass::Mark(mark)) {
 		short const *offset = Overlap_List();
 		short const *occupy = Occupy_List();
 		CELL cell = Coord_Cell(Coord);
 		SmudgeType bib;
 
 		switch (mark) {
 			case MARK_UP:
 				Map.Pick_Up(cell, this);
 				if (Class->Bib_And_Offset(bib, cell)) {
 					SmudgeClass * smudge = new SmudgeClass(bib);
 					if (smudge) {
 						smudge->Disown(cell);
 						delete smudge;
 					}
 				}
 				break;
 
 			case MARK_DOWN:
 
 				/*
 				**	Special wall logic is handled here. A building that is really a wall
 				**	gets converted into an overlay wall type when it is placed down. The
 				**	actual building object itself is destroyed.
 				*/
 				if (Class->IsWall) {
 					switch (Class->Type) {
 						case STRUCT_BRICK_WALL:
 							new OverlayClass(OVERLAY_BRICK_WALL, cell, House->Class->House);
 							break;
 
 						case STRUCT_BARBWIRE_WALL:
 							new OverlayClass(OVERLAY_BARBWIRE_WALL, cell, House->Class->House);
 							break;
 
 						case STRUCT_SANDBAG_WALL:
 							new OverlayClass(OVERLAY_SANDBAG_WALL, cell, House->Class->House);
 							break;
 
 						case STRUCT_WOOD_WALL:
 							new OverlayClass(OVERLAY_WOOD_WALL, cell, House->Class->House);
 							break;
 
 						case STRUCT_CYCLONE_WALL:
 							new OverlayClass(OVERLAY_CYCLONE_WALL, cell, House->Class->House);
 							break;
 					}
 					Transmit_Message(RADIO_OVER_OUT);
 					Delete_This();
 
 				} else {
 
 					if (Can_Enter_Cell(cell) == MOVE_OK) {
 
 						/*
 						**	Determine if a bib is required for this building. If one is, then
 						**	create and place it.
 						*/
 						CELL newcell = cell;
 						if (Class->Bib_And_Offset(bib, newcell)) {
 							new SmudgeClass(bib, Cell_Coord(newcell), House->Class->House);
 						}
 
 						Map.Place_Down(cell, this);
 					} else {
 						return(false);
 					}
 				}
 				break;
 
 			default:
 				Map.Refresh_Cells(cell, offset);
 				Map.Refresh_Cells(cell, occupy);
 				break;
 		}
 		return(true);
 	}
 	return(false);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Fire_At -- Fires weapon at specified target.                                 *
  *                                                                                             *
  *    This routine does the actual firing of a projectile from the                             *
  *    building toward the specified target. Prior to calling this                              *
  *    routine, the building must have rotated into position and acquired                       *
  *    a suitable target.                                                                       *
  *                                                                                             *
  * INPUT:   target   -- The target to fire upon.                                               *
  *                                                                                             *
  *          which    -- Which weapon to use for firing. 0=primary, 1=secondary.                *
  *                                                                                             *
  * OUTPUT:  Returns with a pointer to the projectile just launched. This                       *
  *          may come in handy if additional adjustments to the projectile                      *
  *          are required.                                                                      *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   04/16/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 BulletClass * BuildingClass::Fire_At(TARGET target, int which)
 {
 	Validate();
 	BulletClass * bullet;		// Projectile.
 	WeaponTypeClass const * weapon = (which == 0) ? &Weapons[Class->Primary] : &Weapons[Class->Secondary];
 
 	bullet = TechnoClass::Fire_At(target, which);
 	if (bullet) {
 		if (*this == STRUCT_SAM) {
 			AnimClass *anim = new AnimClass((AnimType)(ANIM_SAM_N + Dir_Facing(PrimaryFacing.Current())), Center_Coord());
 			if (anim) {
 				anim->Attach_To(this);
 			}
 
 			// MBL 04.17.2020
 			Sound_Effect(weapon->Sound, Coord);
 
 		} else {
 
 			/*
 			**	Flash the muzzle, play sound, and perform any firing animation.
 			*/
 			Sound_Effect(weapon->Sound, Coord);
 
 			AnimClass* anim = NULL;
 			if (weapon->Fires == BULLET_BULLET) {
 				anim = new AnimClass((AnimType)(ANIM_GUN_N + Dir_Facing(PrimaryFacing.Current())), Fire_Coord(which));
 			} else {
 				switch (weapon->Fires) {
 				case BULLET_SPREADFIRE:
 					break;
 				case BULLET_LASER:
 					IsCharging = false;
 					IsCharged = false;
 					Set_Stage(0);
 					Set_Rate(0);
 					break;
 				default:
 					anim = new AnimClass(ANIM_MUZZLE_FLASH, Fire_Coord(which));
 					break;
 				}
 			}
 			if (anim != NULL) {
 				anim->Attach_To(this);
 			}
 			Mark(MARK_CHANGE);
 		}
 	}
 
 	return(bullet);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::AI -- Handles non-graphic AI processing for buildings.                       *
  *                                                                                             *
  *    This function is to handle the AI logic for the building. The graphic logic (facing,     *
  *    firing, and animation) is handled elsewhere.                                             *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   05/31/1994 JLB : Created.                                                                 *
  *   12/26/1994 JLB : Handles production.                                                      *
  *   06/11/1995 JLB : Revamped.                                                                *
  *=============================================================================================*/
 void BuildingClass::AI(void)
 {
 	Validate();
 
 	/*
 	**	Process building animation state changes. Transition to a following state
 	**	if there is one specified and the current animation sequence has expired.
 	**	This process must occur before mission AI since the mission AI relies on
 	**	the bstate change to occur immediately before the MissionClass::AI.
 	*/
 	bool stagechange = Graphic_Logic();
 	bool toloop = false;
 
 	/*
 	**	Always refresh the SAM site if it has an animation change.
 	*/
 	if (*this == STRUCT_SAM && stagechange) Mark(MARK_CHANGE);
 
 	if ((!Class->IsTurretEquipped && *this != STRUCT_OBELISK) || Mission == MISSION_CONSTRUCTION || Mission == MISSION_DECONSTRUCTION) {
 		if (stagechange) {
 
 			/*
 			**	Check for animation end or if special case of MCV deconstructing when it is allowed
 			**	to convert back into an MCV.
 			*/
 			BuildingTypeClass::AnimControlType const * ctrl = Fetch_Anim_Control();
 
 			/*
 			**	When the last frame of the current animation sequence is reached, flag that
 			**	a new mission may be started. This must occur before the animation actually
 			**	loops so that if a mission change does occur, it will have a chance to change
 			**	the building graphic before the last frame is replaced by the first frame of
 			**	the loop.
 			*/
 			if (Fetch_Stage() == ctrl->Start+ctrl->Count-1  || (Special.IsMCVDeploy && *this == STRUCT_CONST && Mission == MISSION_DECONSTRUCTION && Fetch_Stage() == (42-19))) {
 				IsReadyToCommence = true;
 			}
 
 			/*
 			**	If the animation advances beyond the last frame, then start the animation
 			**	sequence over from the beginning.
 			*/
 			if (Fetch_Stage() >= ctrl->Start+ctrl->Count) {
 				toloop = true;
 			}
 			Mark(MARK_CHANGE);
 		} else {
 			if (BState == BSTATE_NONE || Fetch_Rate() == 0) {
 				IsReadyToCommence = true;
 			}
 		}
 	}
 
 	/*
 	**	If there is a door that is animating, then it might cause this building
 	**	to be redrawn. Check for and flag to redraw as necessary.
 	*/
 	if (Time_To_Redraw()) {
 		Clear_Redraw_Flag();
 		Mark(MARK_CHANGE);
 	}
 
 	/*
 	**	The animation sequence has looped. Restart it and flag this loop condition.
 	**	This is used to tell the mission system that the animation has completed. It
 	**	also signals that now is a good time to act on any pending mission.
 	*/
 	if (toloop) {
 		BuildingTypeClass::AnimControlType const * ctrl = Fetch_Anim_Control();
 		if (BState == BSTATE_CONSTRUCTION || BState == BSTATE_IDLE) {
 			Set_Rate(Options.Normalize_Delay(ctrl->Rate));
 		} else {
 			Set_Rate(ctrl->Rate);
 		}
 		Set_Stage(ctrl->Start);
 		Mark(MARK_CHANGE);
 	}
 
 	/*
 	**	If now is a good time to act on a new mission, then do so. This process occurs
 	**	here because some outside event may have requested a mission change for the building.
 	**	Such outside requests (player input) must be initiated BEFORE the normal AI process.
 	*/
 	if (IsReadyToCommence && BState != BSTATE_CONSTRUCTION) {
 
 		/*
 		**	Clear the commencement flag ONLY if something actually occured. By acting
 		**	this way, a building can set the IsReadyToCommence flag before it goes
 		**	to "sleep" knowing that it will wake up as soon as a new mission comes
 		**	along.
 		*/
 		if (Commence()) {
 			IsReadyToCommence = false;
 		}
 	}
 
 	/*
 	**	Proceed with normal logic processing. This is where the mission processing
 	**	occurs. This call must be located after the animation sequence makes the
 	**	transition to the next frame (see above) in order for the mission logic to
 	**	act at the exact moment of graphic transition BEFORE it has a chance to
 	**	be displayed.
 	*/
 	TechnoClass::AI();
 
 	/*
 	**	If now is a good time to act on a new mission, then do so. This occurs here because
 	**	some AI event may have requested a mission change (usually from another mission
 	**	state machine). This must occur here before it has a chance to render.
 	*/
 	if (IsReadyToCommence) {
 
 		/*
 		**	Clear the commencement flag ONLY if something actually occured. By acting
 		**	this way, a building can set the IsReadyToCommence flag before it goes
 		**	to "sleep" knowing that it will wake up as soon as a new mission comes
 		**	along.
 		*/
 		if (Commence()) {
 			IsReadyToCommence = false;
 		}
 	}
 
 	/*
 	**	If a change of animation was requested, then make the change
 	**	now. The building animation system acts independantly but subordinate
 	**	to the mission state machine system. By performing the animation change-up
 	**	here, the mission AI system is ensured of immediate visual affect when it
 	**	decides to change the animation state of the building.
 	*/
 	if (QueueBState != BSTATE_NONE) {
 		if (BState != QueueBState) {
 			BState = QueueBState;
 			BuildingTypeClass::AnimControlType const * ctrl = Fetch_Anim_Control();
 			if (BState == BSTATE_CONSTRUCTION || BState == BSTATE_IDLE) {
 				Set_Rate(Options.Normalize_Delay(ctrl->Rate));
 			} else {
 				Set_Rate(ctrl->Rate);
 			}
 			Set_Stage(ctrl->Start);
 		}
 		QueueBState = BSTATE_NONE;
 	}
 
 	/*
 	**	If the building's strength has changed, then update the power
 	**	accordingly.
 	*/
 	if (Strength != LastStrength) {
 		int oldpower = Power_Output();
 		LastStrength = Strength;
 		int newpower = Power_Output();
 		House->Adjust_Power(newpower - oldpower);
 	}
 
 	/*
 	**	Check to see if the destruction countdown timer is active. If so, then decrement it.
 	**	When this timer reaches zero, the building is removed from the map. All the explosions
 	**	are presumed to be in progress at this time.
 	*/
 	if (!Strength) {
 		if (CountDown.Expired()) {
 			Limbo();
 			Drop_Debris(WhomToRepay);
 			Delete_This();
 		}
 		return;
 	}
 
 	/*
 	**	Obelisk charging logic.
 	*/
 	if (*this == STRUCT_OBELISK && BState != BSTATE_CONSTRUCTION) {
 		if (Target_Legal(TarCom) && House->Power_Fraction() >= 0x0100) {
 			if (!IsCharged) {
 				if (IsCharging) {
 					if (stagechange) {
 						Mark(MARK_CHANGE);
 						if (Fetch_Stage() >= 4) {
 							IsCharged = true;
 							IsCharging = false;
 							Set_Rate(0);
 						}
 					}
 				} else {
 					IsCharged = false;
 					IsCharging = true;
 					Set_Stage(0);
 					Set_Rate(OBELISK_ANIMATION_RATE);
 					Sound_Effect(VOC_LASER_POWER, Coord);
 				}
 			}
 		} else {
 			if (IsCharging || IsCharged) {
 				Mark(MARK_CHANGE);
 				IsCharging = false;
 				IsCharged = false;
 				Set_Stage(0);
 				Set_Rate(0);
 			}
 		}
 	}
 
 	/*
 	**	Handle any repair process that may be going on.
 	*/
 	if (IsRepairing) {
 		if ((Frame % 15) == 0) {
 			IsWrenchVisible = (IsWrenchVisible == false);
 			Mark(MARK_CHANGE);
 			int cost = Class->Repair_Cost();
 			int step = Class->Repair_Step();
 
 			/*
 			**	Check for and expend any necessary monies to continue the repair.
 			*/
 			if (House->Available_Money() >= cost) {
 				House->Spend_Money(cost);
 				Strength += step;
 
 				if (Strength >= Class->MaxStrength) {
 					Strength = Class->MaxStrength;
 					IsRepairing = false;
 				}
 			} else {
 				IsRepairing = false;
 			}
 		}
 	}
 
 	/*
 	**	Handle any production tied to this building. Only computer controlled buildings have
 	**	production attached to the building itself. The player uses the sidebar interface for
 	**	all production control.
 	*/
 	if (Factory && Factory->Has_Completed() && PlacementDelay.Expired()) {
 
 		switch (Exit_Object(Factory->Get_Object())) {
 
 			/*
 			**	If the object could not leave the factory, then either request
 			**	a transport, place the (what must be a) building using another method, or
 			**	abort the production and refund money.
 			*/
 			case 0:
 				Factory->Abandon();
 				delete Factory;
 				Factory = 0;
 				break;
 
 			case 1:
 				PlacementDelay = TICKS_PER_SECOND*3;
 				break;
 
 			case 2:
 				Factory->Completed();
 				delete Factory;
 				Factory = 0;
 				break;
 
 		}
 	}
 
 	/*
 	**	For computer controlled buildings, determine what should be produced and start
 	**	production accordingly.
 	*/
 	if (!House->IsHuman && Mission != MISSION_CONSTRUCTION && Mission != MISSION_DECONSTRUCTION) {
 
 		/*
 		**	Possibly start repair process if the building is below half strength.
 		*/
 		int ratio = 0x0040;
 		if (Scenario > 6) ratio = 0x0080;
 		if (Scenario > 10) ratio = 0x00C0;
 		if (Class->IsRepairable && Health_Ratio() <= (unsigned) ratio) {
 			if (House->Available_Money() >= REPAIR_THRESHHOLD) {
 				Repair(1);
 			} else {
 				if (IsTickedOff && (int)Scenario > 2 && Random_Pick(0, 50) < (int)Scenario && !Trigger) {
 					if (GameToPlay != GAME_NORMAL || Scenario != 15 || PlayerPtr->ActLike != HOUSE_GOOD || *this != STRUCT_TEMPLE) {
 						Sell_Back(1);
 					}
 				}
 			}
 		}
 
 		/*
 		**	Buildings that produce other objects have special factory logic handled here.
 		*/
 		if (Class->ToBuild != RTTI_NONE) {
 
 			if (Factory) {
 
 				/*
 				**	If production has halted, then just abort production and make the
 				**	funds available for something else.
 				*/
 				if (PlacementDelay.Expired() && !Factory->Is_Building()) {
 					Factory->Abandon();
 					delete Factory;
 					Factory = 0;
 				}
 
 			} else {
 
 				/*
 				**	Only look to start production if there is at least a small amount of
 				**	money available. In cases where there is no practical money left, then
 				**	production can never complete -- don't bother starting it.
 				*/
 				if (House->IsStarted && House->Available_Money() > 10) {
 					TechnoTypeClass const * techno = House->Suggest_New_Object(Class->ToBuild);
 
 					/*
 					**	If a suitable object type was selected for production, then start
 					**	producing it now.
 					*/
 					if (techno) {
 						Factory = new FactoryClass;
 						if (Factory) {
 							if (!Factory->Set(*techno, *House)) {
 								delete Factory;
 								Factory = 0;
 							} else {
 #ifdef USE_RA_AI
 								House->Production_Begun(Factory->Get_Object());		// Added for RA AI in TD. ST - 7/26/2019 9:46AM
 #endif
 								Factory->Start();
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 
 	/*
 	**	Check for demolition timeout. When timeout has expired, the building explodes.
 	*/
 	if (IsGoingToBlow && CountDown.Expired()) {
 		
 		/*
 		** Maybe trigger an achivement. ST - 11/14/2019 1:53PM
 		*/
 		TechnoTypeClass const *object_type = Techno_Type_Class();
 		if (object_type) {
 			TechnoClass *saboteur = As_Techno(WhomToRepay);
 			if (saboteur && saboteur->IsActive && saboteur->House && saboteur->House->IsHuman) {
 				On_Achievement_Event(saboteur->House, "BUILDING_DESTROYED_C4", object_type->IniName);
 			}
 		}			
 		
 		SabotagedType = Class->Type;
 		int damage = 5000;
 		Take_Damage(damage, 0, WARHEAD_FIRE, As_Techno(WhomToRepay));
 		Mark(MARK_CHANGE);
 	}
 
 	/*
 	**	If the building was in a recoil state (as it would be just as it fires), then
 	**	restore the building.
 	*/
 	if (IsInRecoilState) {
 		IsInRecoilState = false;
 		Mark(MARK_CHANGE);
 	}
 
 	/*
 	**	Turret equiped buildings must handle turret rotation logic here. This entails
 	**	rotating the turret to the desired facing as well as figuring out what that
 	**	desired facing should be.
 	*/
 	if (Class->IsTurretEquipped && Mission != MISSION_CONSTRUCTION && Mission != MISSION_DECONSTRUCTION) {
 
 		/*
 		**	Rotate turret to match desired facing.
 		*/
 		if (PrimaryFacing.Is_Rotating()) {
 			if (*this == STRUCT_SAM) {
 				if (PrimaryFacing.Rotation_Adjust(15)) {
 					Mark(MARK_CHANGE);
 				}
 			} else {
 				if (PrimaryFacing.Rotation_Adjust(12)) {
 					Mark(MARK_CHANGE);
 				}
 			}
 		}
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Unlimbo -- Removes a building from limbo state.                              *
  *                                                                                             *
  *    Use this routine to transform a building that has been held in limbo                     *
  *    state, into one that really exists on the map. Once a building as                        *
  *    been unlimboed, then it becomes a normal object in the game world.                       *
  *                                                                                             *
  * INPUT:   pos   -- The position to place the building on the map.                            *
  *                                                                                             *
  *          dir (optional) -- not used for this class                                          *
  *                                                                                             *
  * OUTPUT:  bool; Was the unlimbo successful?                                                  *
  *                                                                                             *
  * WARNINGS:   The unlimbo operation might not be successful if the                            *
  *             building could not be placed at the location specified.                         *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   04/16/1994 JLB : Created.                                                                 *
  *   06/07/1994 JLB : Matches virtual function format for base class.                          *
  *   05/09/1995 JLB : Handles wall placement.                                                  *
  *   06/18/1995 JLB : Checks for wall legality before placing down.                            *
  *=============================================================================================*/
 bool BuildingClass::Unlimbo(COORDINATE coord, DirType dir)
 {
 	Validate();
 #ifdef OBSOLETE
 	if (*this == STRUCT_ROAD) {
 		if (Can_Enter_Cell(Coord_Cell(coord), FACING_NONE) == MOVE_OK) {
 			ObjectClass * o = OverlayTypeClass::As_Reference(OVERLAY_ROAD).Create_One_Of(House);
 			if (o && o->Unlimbo(coord)) {
 				Transmit_Message(RADIO_OVER_OUT);
 				Delete_This();
 				return(true);
 			}
 		}
 		return(false);
 	}
 #endif
 
 	/*
 	**	If this is a wall type building, then it never gets unlimboed. Instead, it gets
 	**	converted to an overlay type.
 	*/
 	if (Class->IsWall) {
 		if (Can_Enter_Cell(Coord_Cell(coord), FACING_NONE) == MOVE_OK) {
 			OverlayType otype = OVERLAY_NONE;
 			switch (Class->Type) {
 				case STRUCT_SANDBAG_WALL:
 					otype	= OVERLAY_SANDBAG_WALL;
 					break;
 
 				case STRUCT_CYCLONE_WALL:
 					otype = OVERLAY_CYCLONE_WALL;
 					break;
 
 				case STRUCT_BRICK_WALL:
 					otype = OVERLAY_BRICK_WALL;
 					break;
 
 				case STRUCT_BARBWIRE_WALL:
 					otype = OVERLAY_BARBWIRE_WALL;
 					break;
 
 				case STRUCT_WOOD_WALL:
 					otype = OVERLAY_WOOD_WALL;
 					break;
 			}
 			if (otype != OVERLAY_NONE) {
 				ObjectClass * o = OverlayTypeClass::As_Reference(otype).Create_One_Of(House);
 				if (o && o->Unlimbo(coord)) {
 					Map[Coord_Cell(coord)].Owner = House->Class->House;
 					Transmit_Message(RADIO_OVER_OUT);
 					Delete_This();
 					return(true);
 				}
 			}
 		}
 		return(false);
 	}
 
 	/*
 	**	Normal building unlimbo process.
 	*/
 	if (TechnoClass::Unlimbo(coord, dir)) {
 
 		/*
 		**	Ensure that the owning house knows about the
 		**	new object.
 		*/
 		House->BScan |= (1L << Class->Type);
 		House->ActiveBScan |= (1L << Class->Type);
 
 #ifdef USE_RA_AI
 		//
 		// Added for RA AI in TD. ST - 7/26/2019 9:25AM
 		//
 		House->Recalc_Center();
 #endif
 
 		/*
 		**	Update the total factory type, assuming this building has a factory.
 		*/
 		switch (Class->ToBuild) {
 			case RTTI_AIRCRAFTTYPE:
 				House->AircraftFactories++;
 				break;
 
 			case RTTI_INFANTRYTYPE:
 				House->InfantryFactories++;
 				break;
 
 			case RTTI_UNITTYPE:
 				House->UnitFactories++;
 				break;
 
 			case RTTI_BUILDINGTYPE:
 				House->BuildingFactories++;
 				break;
 
 			default:
 				break;
 		}
 
 		/*
 		**	Possibly the sidebar will be affected by this addition.
 		*/
 		House->IsRecalcNeeded = true;
 		LastStrength = 0;
 
 		// Changed for new multiplayer. ST - 4/3/2019 11:20AM
 		//if ((!IsDiscoveredByPlayer && Map[Coord_Cell(coord)].IsVisible) || GameToPlay != GAME_NORMAL) {
 		//	Revealed(PlayerPtr);
 		//}
 		if (!Is_Discovered_By_Player(House) && Map[Coord_Cell(coord)].Is_Visible(House) || GameToPlay != GAME_NORMAL) {
 			if (House->IsHuman) {
 				Revealed(House);
 			}
 		}
 
 		if (!House->IsHuman) {
 			Revealed(House);
 		}
 
 		//Changed for multiplayer ST - 3/13/2019 5:31PM
 		if (Is_Owned_By_Player()) {
 		//if (IsOwnedByPlayer) {
 			Map.PowerClass::IsToRedraw = true;
 			Map.Flag_To_Redraw(false);
 		}
 		return(true);
 	}
 	return(false);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Take_Damage -- Inflicts damage points upon a building.                       *
  *                                                                                             *
  *    This routine will inflict damage points upon the specified building.                     *
  *    It will handle the damage animation and building destruction. Use                        *
  *    this routine whenever a building is attacked.                                            *
  *                                                                                             *
  * INPUT:   damage   -- Amount of damage to inflict.                                           *
  *                                                                                             *
  *          distance -- The distance from the damage center point to the object's center point.*
  *                                                                                             *
  *          warhead  -- The kind of damage to inflict.                                         *
  *                                                                                             *
  *          source   -- The source of the damage. This is used to change targeting.            *
  *                                                                                             *
  * OUTPUT:  true/false; Was the building destroyed?                                            *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/21/1991     : Created.                                                                 *
  *   04/15/1994 JLB : Converted to member function.                                            *
  *   04/16/1994 JLB : Added warhead modifier to damage.                                        *
  *   06/03/1994 JLB : Added source of damage as target value.                                  *
  *   06/20/1994 JLB : Source is a base class pointer.                                          *
  *   11/22/1994 JLB : Shares base damage handler for techno objects.                           *
  *   07/15/1995 JLB : Power ratio gets adjusted.                                               *
  *=============================================================================================*/
 ResultType BuildingClass::Take_Damage(int & damage, int distance, WarheadType warhead, TechnoClass * source)
 {
 	Validate();
 	ResultType res = RESULT_NONE;
 	int shakes;
 
 	if (this != source) {
 		if (source) Base_Is_Attacked(source);
 
 		short const *offset = Occupy_List();
 
 		/*
 		**	SPECIAL CASE:
 		**	SAM sites that are closed will take half damage, but never less than one point.
 		*/
 		if (*this == STRUCT_SAM && Status == SAM_UNDERGROUND) {
 			damage /= 2;
 			damage++;
 		}
 
 		/*
 		**	Damage from an ion cannon against the Temple of Nod does more damage than
 		**	usual.
 		*/
 		if (GameToPlay == GAME_NORMAL && *this == STRUCT_TEMPLE && warhead == WARHEAD_PB) {
 			damage += damage/2;
 		}
 
 		/*
 		**	Perform the low level damage assessment.
 		*/
 		res = TechnoClass::Take_Damage(damage, distance, warhead, source);
 
 		switch (res) {
 			case RESULT_DESTROYED:
 
 				/*
 				**	Destroy all attached objects.
 				*/
 				while (Attached_Object()) {
 					FootClass * obj = Detach_Object();
 
 					Detach_All(true);
 					delete obj;
 				}
 
 				Sound_Effect(VOC_XPLOBIG4, Coord);
 				while (*offset != REFRESH_EOL) {
 					CELL cell = Coord_Cell(Coord) + *offset++;
 
 					/*
 					**	If the building is destroyed, then lots of
 					**	explosions occur.
 					*/
 					new SmudgeClass(Random_Pick(SMUDGE_CRATER1, SMUDGE_CRATER6), Cell_Coord(cell));
 					if (Random_Pick(0, 1) == 0) {
 						new AnimClass(ANIM_FIRE_SMALL, Coord_Scatter(Cell_Coord(cell), 0x0080), Random_Pick(0, 7), Random_Pick(1, 3));
 						if (Random_Pick(0, 1) == 0) {
 							new AnimClass(ANIM_FIRE_MED, Coord_Scatter(Cell_Coord(cell), 0x0040), Random_Pick(0, 7), Random_Pick(1, 3));
 						}
 					}
 					//Start_Profiler();
 					new AnimClass(ANIM_FBALL1, Coord_Scatter(Cell_Coord(cell), 0x0040), Random_Pick(0,3));
 				}
 
 				shakes = Class->Cost_Of() / 400;
 				if (shakes) {
 					Shake_The_Screen(shakes, Owner());
 					if (source && Owner() != source->Owner()) {
 						Shake_The_Screen(shakes, source->Owner());
 					}
 				}
 				Sound_Effect(VOC_CRUMBLE, Coord);
 				if (Mission == MISSION_DECONSTRUCTION) {
 					CountDown = 0;
 					Set_Rate(0);
 				} else {
 					CountDown = 8;
 				}
 
 				/*
 				**	A destuction of the Temple by an ion cannon requires a global
 				**	remembering of this fact. The finale uses this information to
 				**	play the correct movie.
 				*/
 				if (*this == STRUCT_TEMPLE && warhead == WARHEAD_PB) {
 					TempleIoned = true;
 
 					/*
 					** Maybe trigger an achivement if the structure is owned by an AI house in campaign mode. ST - 11/14/2019 1:53PM
 					*/
 					if (GameToPlay == GAME_NORMAL && !House->IsHuman && source && source->House && source->House->IsHuman) {
 						TechnoTypeClass const *object_type = Techno_Type_Class();
 						if (object_type) {
 							On_Achievement_Event(source->House, "ION_DESTROYS_TEMPLE", object_type->IniName);
 						}			
 					}
 
 				} else {
 					TempleIoned = false;
 				}
 				
 				if (House) {
 					House->Check_Pertinent_Structures();
 				}
 				break;
 
 			case RESULT_HALF:
 				if (*this == STRUCT_PUMP) {
 					AnimClass *anim = new AnimClass(ANIM_OILFIELD_BURN, Coord_Add(Coord, 0x00400130L), 1);
 					if (anim) {
 						anim->Attach_To(this);
 					}
 				}
 				// Fall into next case.
 
 			case RESULT_MAJOR:
 				Sound_Effect(VOC_XPLOBIG4, Coord);
 				while (*offset != REFRESH_EOL) {
 					CELL cell = Coord_Cell(Coord) + *offset++;
 					AnimClass * anim = NULL;
 
 					/*
 					**	Show pieces of fire to indicate that a significant change in
 					**	damage level has occurred.
 					*/
 					if (warhead == WARHEAD_FIRE) {
 						switch (Random_Pick(0, 13)) {
 							case 0:
 							case 1:
 							case 2:
 							case 3:
 							case 4:
 								anim = new AnimClass(ANIM_ON_FIRE_SMALL, Coord_Scatter(Cell_Coord(cell), 0x0060), 0, Random_Pick(1, 3));
 								break;
 
 							case 5:
 							case 6:
 							case 7:
 								anim = new AnimClass(ANIM_ON_FIRE_MED, Coord_Scatter(Cell_Coord(cell), 0x0060), 0, Random_Pick(1, 3));
 								break;
 
 							case 8:
 								anim = new AnimClass(ANIM_ON_FIRE_BIG, Coord_Scatter(Cell_Coord(cell), 0x0060), 0, 1);
 								break;
 
 							case 9:
 							case 10:
 							case 11:
 							case 12:
 							case 13:
 								break;
 						}
 					} else {
 						if (Random_Pick(0, 1) == 0) {
 							anim = new AnimClass(ANIM_FIRE_SMALL, Coord_Scatter(Cell_Coord(cell), 0x0060), Random_Pick(0, 7), Random_Pick(1, 3));
 						}
 					}
 
 					/*
 					**	If the animation was created, then attach it to the building.
 					*/
 					if (anim) {
 						anim->Attach_To(this);
 					}
 				}
 				break;
 
 			case RESULT_NONE:
 				break;
 		}
 
 		if (source && res != RESULT_NONE) {
 
 			/*
 			**	If any damage occurred, then inform the house of this fact. If it is the player's
 			**	house, it might announce this fact.
 			*/
 			House->Attacked(this);
 
 			/*
 			** Save the type of the house that's doing the damage, so if the building burns
 			** to death credit can still be given for the kill
 			*/
 			WhoLastHurtMe = source->Owner();
 
 			/*
 			**	When certain buildings are hit, they "snap out of it" and
 			**	return fire if they are able and allowed.
 			*/
 			if (*this != STRUCT_SAM &&
 				!House->Is_Ally(source) &&
 				Class->Primary != WEAPON_NONE &&
 				(!Target_Legal(TarCom) || !In_Range(TarCom))) {
 
 				if (source->What_Am_I() != RTTI_AIRCRAFT && (!House->IsHuman || Special.IsSmartDefense)) {
 					Assign_Target(source->As_Target());
 				} else {
 
 					/*
 					**	Generate a random rotation effect since there is nothing else that this
 					**	building can do.
 					*/
 					if (!PrimaryFacing.Is_Rotating()) {
 						PrimaryFacing.Set_Desired(Random_Pick(DIR_N, DIR_MAX));
 					}
 				}
 			}
 		}
 	}
 
 	return(res);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Look -- Reveal map around building.                                          *
  *                                                                                             *
  *    Given a building, reveal the cells around the building in accordance                     *
  *    with the building's sighting range.                                                      *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   This is a very slow routine. Call only when necessary.                          *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   08/05/1992 JLB : Created.                                                                 *
  *   04/15/1994 JLB : Converted to member function.                                            *
  *=============================================================================================*/
 void BuildingClass::Look(bool)
 {
 	/*
 	** Changed this function to reveal for the appropriate players in GlyphX multiplayer. ST - 4/17/2019 11:50AM
 	*/
 	Validate();
 
 	if (Class->SightRange) {
 		Map.Sight_From(House, Coord_Cell(Center_Coord()), Class->SightRange, false);
 	}
 
 #if (0)
 	if (GameToPlay != GAME_GLYPHX_MULTIPLAYER) {
 
 		if (Is_Owned_By_Player(PlayerPtr) || Is_Discovered_By_Player(PlayerPtr)) {
 			Map.Sight_From(PlayerPtr, Coord_Cell(Center_Coord()), Class->SightRange, false);
 		}
 	} else {
 		
 		for (int i = 0; i < MPlayerCount; i++) {
 			HousesType house_type = MPlayerHouses[i];
 			HouseClass *house = HouseClass::As_Pointer(house_type);
 
 			if (Is_Owned_By_Player(house) || Is_Discovered_By_Player(house)) {
 				Map.Sight_From(house, Coord_Cell(Center_Coord()), Class->SightRange, false);
 			}
 		}
 	}
 #endif
 }
 
 
 #if (0)                                 // For reference. ST - 4/17/2019 11:38AM
 void BuildingClass::Look(bool)
 {
 	Validate();
 	if (IsOwnedByPlayer || IsDiscoveredByPlayer) {
 		Map.Sight_From(PlayerPtr, Coord_Cell(Center_Coord()), Class->SightRange, false);
 	}
 }
 #endif
 
 
 /***********************************************************************************************
  * BuildingClass::new -- Allocates a building object from building pool.                       *
  *                                                                                             *
  *    This routine will allocate a building slot from the building alloc                       *
  *    system.                                                                                  *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with a pointer to the allocated building. If NULL is                       *
  *          returned, then this indicates a failure to allocate.                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   04/11/1994 JLB : Created.                                                                 *
  *   04/21/1994 JLB : Converted to operator new.                                               *
  *   05/17/1994 JLB : Revamped allocation scheme                                               *
  *   07/29/1994 JLB : Simplified.                                                              *
  *=============================================================================================*/
 void * BuildingClass::operator new(size_t )
 {
 	void * ptr = Buildings.Allocate();
 	if (ptr) {
 		((BuildingClass *)ptr)->Set_Active();
 	}
 	return(ptr);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::delete -- Deallocates building object.                                       *
  *                                                                                             *
  *    This is the memory deallocation operation for a building object.                         *
  *    Since buildings are allocated out of a fixed memory block, all that                      *
  *    is needed is to flag the unit as inactive.                                               *
  *                                                                                             *
  * INPUT:   ptr   -- Pointer to building to deallocate.                                        *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   04/21/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::operator delete(void *ptr)
 {
 	if (ptr) {
 		((BuildingClass *)ptr)->IsActive = false;
 	}
 	Buildings.Free((BuildingClass *)ptr);
 
 	//Map.Validate();
 }
 
 
 /***********************************************************************************************
  * BuildingClass::BuildingClass -- Constructor for buildings.                                  *
  *                                                                                             *
  *    This routine inserts a building into the object tracking system.                         *
  *    It is placed into a limbo state unless a location is provided for                        *
  *    it to unlimbo at.                                                                        *
  *                                                                                             *
  * INPUT:   type  -- The structure type to make this object.                                   *
  *                                                                                             *
  *          house -- The owner of this building.                                               *
  *                                                                                             *
  *          pos   -- The position to unlimbo the building. If -1 is                            *
  *                   specified, then the building remains in a limbo                           *
  *                   state.                                                                    *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   04/21/1994 JLB : Created.                                                                 *
  *   08/07/1995 JLB : Fixed act like value to match expected value.                            *
  *=============================================================================================*/
 BuildingClass::BuildingClass(StructType type, HousesType house) :
 	Class(&BuildingTypeClass::As_Reference(type)),
 	TechnoClass(house)
 {
 	PlacementDelay = 0;
 	LastStrength = 0;
 	ActLike = House->ActLike;
 	BState = BSTATE_NONE;
 	CountDown.Set(0);
 	Factory = 0;
 #ifndef USE_RA_AI
 	House->CurBuildings++;		       // Removed for RA AI in TD
 #endif
 	WhomToRepay = TARGET_NONE;
 	IsCaptured = false;
 	IsCharged = false;
 	IsCharging = false;
 	IsSurvivorless = false;
 	IsGoingToBlow = false;
 	IsReadyToCommence = false;
 	IsRepairing = false;
 	IsSecondShot = !Class->IsTwoShooter;
 	IsWrenchVisible = false;
 	QueueBState = BSTATE_NONE;
 	Strength = Class->MaxStrength;
 	WhoLastHurtMe = house;
 	Ammo = Class->MaxAmmo;
 
 	/*
 	**	Make sure that newly built house specific building types will act like
 	**	the house they are supposed to act like, regardless of who the current
 	**	owner may happen to be.
 	*/
 	if ((type == STRUCT_AIRSTRIP || type == STRUCT_HAND) && house != HOUSE_BAD) {
 		ActLike = HOUSE_BAD;
 		IsCaptured = true;
 	}
 	if ((type == STRUCT_WEAP || type == STRUCT_BARRACKS) && house != HOUSE_GOOD) {
 		ActLike = HOUSE_GOOD;
 		IsCaptured = true;
 	}
 
 	if (GameToPlay == GAME_INTERNET){
 		House->BuildingTotals->Increment_Unit_Total( (int) type);
 	}
 
 #ifdef USE_RA_AI
 	//
 	// Added for RA AI in TD. ST - 7/26/2019 9:12AM
 	//
 	House->Tracking_Add(this);
 #endif // USE_RA_AI
 }
 
 
 /***********************************************************************************************
  * BuildingClass::~BuildingClass -- Destructor for building type objects.                      *
  *                                                                                             *
  *    This destructor for building objects will put the building in limbo if possible.         *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   01/18/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 BuildingClass::~BuildingClass(void)
 {
 	if (GameActive && Class) {
 		if (House) {
 #ifndef USE_RA_AI
 			House->CurBuildings--;
 #else
 			//
 			// Added for RA AI in TD. ST - 7/26/2019 9:12AM
 			//
 			House->Tracking_Remove(this);
 #endif
 		}
 		Limbo();
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Drop_Debris -- Drops rubble when building is destroyed.                      *
  *                                                                                             *
  *    This routine is called when a building is destroyed. It handles                          *
  *    placing the rubble down.                                                                 *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   05/14/1994 JLB : Created.                                                                 *
  *   06/13/1995 JLB : Added smoke and normal infantry survivor possibility.                    *
  *   07/16/1995 JLB : Survival rate depends on if captured or sabotaged.                       *
  *=============================================================================================*/
 void BuildingClass::Drop_Debris(TARGET source)
 {
 	Validate();
 	CELL	const *offset;
 	CELL	cell;
 
 	/*
 	**	Special case for Chan to run from destroyed technology
 	**	building.
 	*/
 	if (GameToPlay == GAME_NORMAL && *this ==  STRUCT_MISSION && PlayerPtr->ActLike == HOUSE_BAD && Scenario == 10) {
 		InfantryClass * i = new InfantryClass(INFANTRY_CHAN, House->Class->House);
 
 		ScenarioInit++;
 		if (i->Unlimbo(Center_Coord(), DIR_N)) {
 			i->Trigger = TriggerClass::As_Pointer("win");
 			i->Strength = Random_Pick(5, (int)i->Class->MaxStrength);
 			ScenarioInit--;
 			i->Scatter(0, true);
 			ScenarioInit++;
 			i->Assign_Mission(MISSION_GUARD_AREA);
 		} else {
 			delete i;
 			PlayerPtr->Flag_To_Win();
 		}
 		ScenarioInit--;
 	}
 
 
 	/*
 	**	Generate random survivors from the destroyed building.
 	*/
 	cell = Coord_Cell(Coord);
 	offset = Occupy_List();
 	int odds = 2;
 	if (Target_Legal(WhomToRepay)) odds -= 1;
 	if (IsCaptured) odds += 6;
 	while (*offset != REFRESH_EOL) {
 		CELL	newcell;
 
 		newcell = cell + *offset++;
 
 		/*
 		**	Infantry could run out of a destroyed building.
 		*/
 		if (!House->IsToDie && !IsSurvivorless) {
 			InfantryClass * i = NULL;
 
 			if (Random_Pick(0, odds) == 1) {
 				i = new InfantryClass(Crew_Type(), House->Class->House);
 				if (i) {
 					if (Class->Get_Buildup_Data() != NULL && i->Class->IsNominal) i->IsTechnician = true;
 					ScenarioInit++;
 					if (i->Unlimbo(Cell_Coord(newcell), DIR_N)) {
 						i->Strength = Random_Pick(5, (int)i->Class->MaxStrength);
 						i->Scatter(0, true);
 						if (source != TARGET_NONE && !House->Is_Ally(As_Object(source))) {
 							i->Assign_Mission(MISSION_ATTACK);
 							i->Assign_Target(source);
 						} else {
 							if (House->IsHuman) {
 								i->Assign_Mission(MISSION_GUARD);
 							} else {
 								i->Assign_Mission(MISSION_HUNT);
 							}
 						}
 					} else {
 						delete i;
 					}
 					ScenarioInit--;
 				}
 			}
 		}
 
 		/*
 		**	Possibly add some smoke rising from the ashes of the building.
 		*/
 		switch (Random_Pick(0, 5)) {
 			case 0:
 			case 1:
 			case 2:
 				new AnimClass(ANIM_SMOKE_M, Coord_Scatter(Cell_Coord(newcell), 0x0050, false), Random_Pick(0, 5), Random_Pick(1, 2));
 				break;
 
 			default:
 				break;
 		}
 
 		/*
 		**	The building always scars the ground in some fashion.
 		*/
 		if (Random_Pick(0, 3) == 0) {
 			new SmudgeClass(Random_Pick(SMUDGE_SCORCH1, SMUDGE_SCORCH6), Cell_Coord(newcell));
 		} else {
 			new SmudgeClass(Random_Pick(SMUDGE_CRATER1, SMUDGE_CRATER6), Coord_Scatter(Cell_Coord(newcell), 0x0080, false));
 		}
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Active_Click_With -- Handles clicking on the map while the building is selected.*
  *                                                                                             *
  *    This interface routine handles when the player clicks on the map while this building     *
  *    is currently selected. This is used to assign an override target to a turret or          *
  *    guard tower.                                                                             *
  *                                                                                             *
  * INPUT:   target   -- The target that was clicked upon.                                      *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   05/28/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Active_Click_With(ActionType action, ObjectClass * object)
 {
 	Validate();
 	if (action == ACTION_ATTACK) {
 		Player_Assign_Mission(MISSION_ATTACK, object->As_Target());
 	}
 
 	if (action == ACTION_TOGGLE_PRIMARY && Class->IsFactory) {
 		OutList.Add(EventClass(EventClass::PRIMARY, As_Target()));
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Active_Click_With -- Handles cell selection for buildings.                   *
  *                                                                                             *
  *    This routine really only serves one purpose -- to allow targeting of the ground for      *
  *    buildings that are euipped with weapons.                                                 *
  *                                                                                             *
  * INPUT:   action   -- The requested action to perform.                                       *
  *                                                                                             *
  *          cell     -- The cell location to perform the action upon.                          *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/04/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Active_Click_With(ActionType action, CELL cell)
 {
 	Validate();
 	if (action == ACTION_ATTACK) {
 		Player_Assign_Mission(MISSION_ATTACK, ::As_Target(cell));
 	}
 
 	if (action == ACTION_MOVE && *this == STRUCT_CONST) {
 		OutList.Add(EventClass(EventClass::ARCHIVE, As_Target(), ::As_Target(cell)));
 		OutList.Add(EventClass(EventClass::SELL, As_Target()));
 
 		COORDINATE coord = Map.Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y());
 		OutList.Add(EventClass(ANIM_MOVE_FLASH, PlayerPtr->Class->House, coord, 1 << PlayerPtr->Class->House));
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Assign_Target -- Assigns a target to the building.                           *
  *                                                                                             *
  *    Assigning of a target to a building makes sense if the building is one that can attack.  *
  *    This routine would be used to assign the attack target to a turret or guard tower.       *
  *                                                                                             *
  * INPUT:   target   -- The target that was clicked on while this building was selected.       *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   05/28/1994 JLB : Created.                                                                 *
  *   11/02/1994 JLB : Checks for range before assigning target.                                *
  *=============================================================================================*/
 void BuildingClass::Assign_Target(TARGET target)
 {
 	Validate();
 	if (*this != STRUCT_SAM && !In_Range(target, 0)) {
 		target = TARGET_NONE;
 	}
 
 	TechnoClass::Assign_Target(target);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Init -- Initialize the building system to an empty null state.               *
  *                                                                                             *
  *    This routine initializes the building system in preparation for a scenario load.         *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   09/19/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Init(void)
 {
 	BuildingClass *ptr;
 
 	Buildings.Free_All();
 
 	ptr = new BuildingClass();
 	VTable = ((void **)(((char *)ptr) + sizeof(AbstractClass) - 4))[0];
 	delete ptr;
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Exit_Object -- Initiates an object to leave the building.                    *
  *                                                                                             *
  *    This function is used to cause an object to exit the building. It is called when a       *
  *    factory produces a vehicle or other mobile object and that object needs to exit the      *
  *    building to join the ranks of a regular unit. Typically, the object is placed down on    *
  *    the map such that it overlaps the building and then it is given a movement order so that *
  *    it will move to an adjacent free cell.                                                   *
  *                                                                                             *
  * INPUT:   base  -- Pointer to the object that is to exit the building.                       *
  *                                                                                             *
  * OUTPUT:  Returns the success rating for the exit attempt;                                   *
  *             0  = complete failure (refund money please)                                     *
  *             1  = temporarily prevented (try again later please)                             *
  *             2  = successful                                                                 *
  *                                                                                             *
  * WARNINGS:   The building is placed in radio contact with the object. The object is in a     *
  *             teathered condition. This condition will be automatically broken when the       *
  *             object reaches the adjacent square.                                             *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   11/28/1994 JLB : Created.                                                                 *
  *   04/10/1995 JLB : Handles building production by computer.                                 *
  *   06/17/1995 JLB : Handles refinery exit.                                                   *
  *=============================================================================================*/
 int BuildingClass::Exit_Object(TechnoClass * base)
 {
 	Validate();
 	if (!base) return(0);
 
 	TechnoTypeClass const * ttype = (TechnoTypeClass const *)&base->Class_Of();
 
 	/*
 	**	A unit exiting a building is always considered to be "locked". That means, it
 	**	will be considered as to have legally entered the visible map domain.
 	*/
 	base->IsLocked = true;
 
 	/*
 	**	Find a good cell to unload the object to. The object, probably a vehicle
 	**	will drive/walk to the adjacent free cell.
 	*/
 	switch (base->What_Am_I()) {
 		CELL cell;
 
 		case RTTI_AIRCRAFT:
 			if (!In_Radio_Contact()) {
 				AircraftClass *air = (AircraftClass *)base;
 
 				air->Altitude = 0;
 				ScenarioInit++;
 				if (air->Unlimbo(Docking_Coord(), air->Pose_Dir())) {
 					Transmit_Message(RADIO_HELLO, air);
 					Transmit_Message(RADIO_TETHER);
 					ScenarioInit--;
 					return(2);
 				}
 				ScenarioInit--;
 			} else {
 				AircraftClass *air = (AircraftClass *)base;
 
 				if (Cell_X(Coord_Cell(Center_Coord())) - Map.MapCellX < Map.MapCellWidth/2) {
 					cell = XY_Cell(Map.MapCellX-1, Random_Pick(0, Map.MapCellHeight-1)+Map.MapCellY);
 				} else {
 					cell = XY_Cell(Map.MapCellX+Map.MapCellWidth, Random_Pick(0, Map.MapCellHeight-1)+Map.MapCellY);
 				}
 				ScenarioInit++;
 				if (air->Unlimbo(Cell_Coord(cell), DIR_N)) {
 					air->Assign_Destination(::As_Target(Nearby_Location(air)));
 					air->Assign_Mission(MISSION_MOVE);
 					ScenarioInit--;
 					return(2);
 				}
 				ScenarioInit--;
 			}
 			break;
 
 		case RTTI_INFANTRY:
 		case RTTI_UNIT:
 			switch (Class->Type) {
 				case STRUCT_REFINERY:
 					if (base->What_Am_I() == RTTI_UNIT) {
 						CELL cell = Coord_Cell(Center_Coord());
 						UnitClass * unit = (UnitClass *)base;
 
 						cell = Adjacent_Cell(cell, FACING_SW);
 						ScenarioInit++;
 						if (unit->Unlimbo(Coord_Add(unit->Coord, 0x00550060L), DIR_SW_X2)) {
 							unit->PrimaryFacing = DIR_SW_X2;
 							Transmit_Message(RADIO_HELLO, unit);
 							Transmit_Message(RADIO_TETHER);
 							unit->Assign_Mission(MISSION_HARVEST);
 							unit->Force_Track(DriveClass::OUT_OF_REFINERY, Cell_Coord(cell));
 							unit->Set_Speed(128);
 						}
 						ScenarioInit--;
 					} else {
 						base->Scatter(true);
 					}
 					break;
 
 				case STRUCT_AIRSTRIP:
 					if (Create_Special_Reinforcement(House, &AircraftTypeClass::As_Reference(AIRCRAFT_CARGO), ttype, TMISSION_UNLOAD, As_Target())) {
 						delete base;
 						return(2);
 					}
 					return(0);
 
 				case STRUCT_WEAP:
 					ScenarioInit++;
 					if (base->Unlimbo(Coord_Add(Coord, Class->ExitPoint), DIR_SW)) {
 //						base->Assign_Mission(MISSION_MOVE);
 //						base->Assign_Destination(::As_Target(As_Cell(Coord)+MAP_CELL_W*2));
 						base->Mark(MARK_UP);
 						base->Coord = Coord_Add(Coord, Class->ExitPoint);
 						base->Mark(MARK_DOWN);
 						Transmit_Message(RADIO_HELLO, base);
 						Transmit_Message(RADIO_TETHER);
 						Assign_Mission(MISSION_UNLOAD);
 						ScenarioInit--;
 						return(2);
 					}
 					ScenarioInit--;
 					break;
 
 				case STRUCT_BARRACKS:
 				case STRUCT_HAND:
 					CELL cell;
 					bool found = false;
 
 					cell = Find_Exit_Cell(base);
 					if (cell) found = true;
 
 #ifdef OBSOLETE
 					CELL	const *ptr;
 					bool	found = false;
 
 					ptr = Class->ExitList;
 					while (*ptr != REFRESH_EOL) {
 						cell = Coord_Cell(Coord) + *ptr++;
 						if (base->Can_Enter_Cell(cell) == MOVE_OK) {
 							found = true;
 							break;
 						}
 					}
 #endif
 
 					if (found) {
 						DirType	dir = Direction(cell);
 						COORDINATE		start = Coord_Add(Coord, Class->ExitPoint);
 
 						ScenarioInit++;
 						if (base->Unlimbo(start, dir)) {
 
 							base->Assign_Mission(MISSION_MOVE);
 							base->Assign_Destination(::As_Target(cell));
 
 							/*
 							**	Establish radio contact so unload coordination can occur. This
 							**	radio contact should always succeed.
 							*/
 							if (Transmit_Message(RADIO_HELLO, base) == RADIO_ROGER) {
 								Transmit_Message(RADIO_UNLOAD);
 							}
 							ScenarioInit--;
 							return(2);
 						}
 						ScenarioInit--;
 					}
 					break;
 			}
 			break;
 
 		case RTTI_BUILDING:
 
 			if (!House->IsHuman) {
 				/*
 				**	Find the next available spot to place this newly created building. If the
 				**	building could be placed at the desired location, fine. If not, then this
 				**	routine will return failure. The calling routine will probably abandon this
 				**	building in preference to building another.
 				*/
 				
 				BaseNodeClass * node = Base.Next_Buildable(((BuildingClass *)base)->Class->Type);
 				// Replaced with RA AI functioality. ST - 7/25/2019 4:14PM
 #ifndef USE_RA_AI
 				if (node) {
 					if (Flush_For_Placement(base, Coord_Cell(node->Coord))) {
 						return(1);
 					}
 					if (base->Unlimbo(node->Coord)) {
 						return(2);
 					}
 				}
 #else
 				if (GameToPlay == GAME_NORMAL) {
 					if (node) {
 						if (Flush_For_Placement(base, Coord_Cell(node->Coord))) {
 							return(1);
 						}
 						if (base->Unlimbo(node->Coord)) {
 							return(2);
 						}
 					}
 				} else {
 					
 					COORDINATE coord = 0;
 					if (node) {
 						coord = node->Coord;
 					} else {
 
 						/*
 						**	Find a suitable new spot to place.
 						*/
 						coord = House->Find_Build_Location((BuildingClass *)base);
 					}
 
 					if (coord) {
 						if (Flush_For_Placement(base, Coord_Cell(coord))) {
 							return(1);
 						}
 						if (base->Unlimbo(coord)) {
 							if (node && ((BuildingClass *)base)->Class->Type == House->BuildStructure) {
 								House->BuildStructure = STRUCT_NONE;
 							}
 							return(2);
 						}
 					}
 				}
 #endif
 			}
 			break;
 	}
 
 	/*
 	**	Failure to exit the object results in a false return value.
 	*/
 	return(0);
 }
 
 
 
 
 
 /***********************************************************************************************
  * BuildingClass::Update_Buildables -- Informs sidebar of additional construction options.     *
  *                                                                                             *
  *    This routine will tell the sidebar of objects that can be built. The function is called  *
  *    whenever a building matures.                                                             *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   11/11/1994 JLB : Created.                                                                 *
  *   12/23/1994 JLB : Only updates for PLAYER buildings.                                       *
  *=============================================================================================*/
 void BuildingClass::Update_Buildables(void)
 {
 	Validate();
 	
 	/*
 	** Only do this for real human players. ST - 3/22/2019 1:38PM
 	*/
 	if (House != PlayerPtr) {
 		if (GameToPlay != GAME_GLYPHX_MULTIPLAYER || House->IsHuman == false) {
 			return;
 		}
 	}
 
 	bool buildable_via_capture = (IsCaptured && ActLike != House->ActLike) ? true : false;
 
 	if (!IsInLimbo && Is_Discovered_By_Player()) {
 		switch (Class->ToBuild) {
 			StructType i;
 			UnitType u;
 			InfantryType f;
 			AircraftType a;
 
 			case RTTI_BUILDINGTYPE:
 				for (i = STRUCT_FIRST; i < STRUCT_COUNT; i++) {
 					if (PlayerPtr->Can_Build(i, ActLike)) {
 //						if (BuildingTypeClass::As_Reference(i).Who_Can_Build_Me(true, true, ActLike)) {
 							if (GameToPlay == GAME_GLYPHX_MULTIPLAYER) {
 								Sidebar_Glyphx_Add(RTTI_BUILDINGTYPE, i, House, buildable_via_capture);
 							} else {
 								Map.Add(RTTI_BUILDINGTYPE, i, buildable_via_capture);
 							}
 //						}
 					}
 				}
 				break;
 
 			case RTTI_UNITTYPE:
 				for (u = UNIT_FIRST; u < UNIT_COUNT; u++) {
 					if (PlayerPtr->Can_Build(u, ActLike)) {
 //						if (UnitTypeClass::As_Reference(u).Who_Can_Build_Me(true, true, ActLike)) {
 							if (GameToPlay == GAME_GLYPHX_MULTIPLAYER) {
 								Sidebar_Glyphx_Add(RTTI_UNITTYPE, u, House, buildable_via_capture);
 							} else {
 								Map.Add(RTTI_UNITTYPE, u, buildable_via_capture);
 							}
 //						}
 					}
 				}
 				break;
 
 			case RTTI_INFANTRYTYPE:
 				for (f = INFANTRY_FIRST; f < INFANTRY_COUNT; f++) {
 					if (PlayerPtr->Can_Build(f, ActLike)) {
 //						if (InfantryTypeClass::As_Reference(f).Who_Can_Build_Me(true, true, ActLike)) {
 							if (GameToPlay == GAME_GLYPHX_MULTIPLAYER) {
 								Sidebar_Glyphx_Add(RTTI_INFANTRYTYPE, f, House, buildable_via_capture);
 							} else {
 								Map.Add(RTTI_INFANTRYTYPE, f, buildable_via_capture);
 							}
 //						}
 					}
 				}
 				break;
 
 			case RTTI_AIRCRAFTTYPE:
 				for (a = AIRCRAFT_FIRST; a < AIRCRAFT_COUNT; a++) {
 					if (PlayerPtr->Can_Build(a, ActLike)) {
 //						if (AircraftTypeClass::As_Reference(a).Who_Can_Build_Me(true, true, ActLike)) {
 							if (GameToPlay == GAME_GLYPHX_MULTIPLAYER) {
 								Sidebar_Glyphx_Add(RTTI_AIRCRAFTTYPE, a, House, buildable_via_capture);
 							} else {
 								Map.Add(RTTI_AIRCRAFTTYPE, a, buildable_via_capture);
 							}
 //						}
 					}
 				}
 				break;
 		}
 	}
 }
 
 #if (0)	//ST - 3/22/2019 1:33PM
 /***********************************************************************************************
  * BuildingClass::Update_Buildables -- Informs sidebar of additional construction options.     *
  *                                                                                             *
  *    This routine will tell the sidebar of objects that can be built. The function is called  *
  *    whenever a building matures.                                                             *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   11/11/1994 JLB : Created.                                                                 *
  *   12/23/1994 JLB : Only updates for PLAYER buildings.                                       *
  *=============================================================================================*/
 void BuildingClass::Update_Buildables(void)
 {
 	Validate();
 
 	if (House == PlayerPtr && !IsInLimbo && IsDiscoveredByPlayer) {
 		switch (Class->ToBuild) {
 			StructType i;
 			UnitType u;
 			InfantryType f;
 			AircraftType a;
 
 			case RTTI_BUILDINGTYPE:
 				for (i = STRUCT_FIRST; i < STRUCT_COUNT; i++) {
 					if (PlayerPtr->Can_Build(i, ActLike)) {
 //						if (BuildingTypeClass::As_Reference(i).Who_Can_Build_Me(true, true, ActLike)) {
 							Map.Add(RTTI_BUILDINGTYPE, i);
 //						}
 					}
 				}
 				break;
 
 			case RTTI_UNITTYPE:
 				for (u = UNIT_FIRST; u < UNIT_COUNT; u++) {
 					if (PlayerPtr->Can_Build(u, ActLike)) {
 //						if (UnitTypeClass::As_Reference(u).Who_Can_Build_Me(true, true, ActLike)) {
 							Map.Add(RTTI_UNITTYPE, u);
 //						}
 					}
 				}
 				break;
 
 			case RTTI_INFANTRYTYPE:
 				for (f = INFANTRY_FIRST; f < INFANTRY_COUNT; f++) {
 					if (PlayerPtr->Can_Build(f, ActLike)) {
 //						if (InfantryTypeClass::As_Reference(f).Who_Can_Build_Me(true, true, ActLike)) {
 							Map.Add(RTTI_INFANTRYTYPE, f);
 //						}
 					}
 				}
 				break;
 
 			case RTTI_AIRCRAFTTYPE:
 				for (a = AIRCRAFT_FIRST; a < AIRCRAFT_COUNT; a++) {
 					if (PlayerPtr->Can_Build(a, ActLike)) {
 //						if (AircraftTypeClass::As_Reference(a).Who_Can_Build_Me(true, true, ActLike)) {
 							Map.Add(RTTI_AIRCRAFTTYPE, a);
 //						}
 					}
 				}
 				break;
 		}
 	}
 }
 #endif
 
 /***********************************************************************************************
  * BuildingClass::Fire_Out -- Handles when attached animation expires.                         *
  *                                                                                             *
  *    This routine is used to perform any fixups necessary when the attached animation has     *
  *    terminated. This occurs when the fire & smoke animation that a SAM site produces stops.  *
  *    At that point, normal reload procedures can commence.                                    *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   11/30/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Fire_Out(void)
 {
 	Validate();
 //	SAM = SAM_READY;
 //	IsFiring = false;
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Limbo -- Handles power adjustment as building goes into limbo.               *
  *                                                                                             *
  *    This routine will handle the power adjustments for the associated house when the         *
  *    building goes into limbo. This means that its power drain or production is subtracted    *
  *    from the house accumulated totals.                                                       *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  bool; Was the building limboed?                                                    *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   12/24/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool BuildingClass::Limbo(void)
 {
 	Validate();
 //	HouseClass *housep;
 //	RTTIType bld_type;
 
 	if (!IsInLimbo) {
 
 		/*
 		**	Update the total factory type, assuming this building has a factory.
 		*/
 		switch (Class->ToBuild) {
 			case RTTI_AIRCRAFTTYPE:
 				House->AircraftFactories--;
 				break;
 
 			case RTTI_INFANTRYTYPE:
 				House->InfantryFactories--;
 				break;
 
 			case RTTI_UNITTYPE:
 				House->UnitFactories--;
 				break;
 
 			case RTTI_BUILDINGTYPE:
 				House->BuildingFactories--;
 				break;
 
 			default:
 				break;
 		}
 
 		House->IsRecalcNeeded = true;
 		
 #ifdef USE_RA_AI
 		//
 		// Added for RA AI in TD. ST - 7/26/2019 9:25AM
 		//
 		House->Recalc_Center();
 #endif
 		/*
 		**	Update the power status of the owner's house.
 		*/
 		House->Adjust_Power(-Power_Output());
 		House->Adjust_Drain(-Class->Drain);
 		House->Adjust_Capacity(-(int)Class->Capacity, true);
 		if (House == PlayerPtr) {
 			Map.PowerClass::IsToRedraw = true;
 			Map.Flag_To_Redraw(false);
 		}
 
 #ifdef OBSOLETE
 		/*
 		**	If this building is building something, the FactoryClass doing the
 		**	building must be deleted, as well as the object being built.
 		**	- If this building is controlled by Computer AI, this building's Factory
 		**	  pointer will point to the factory doing the building.
 		**	- Otherwise, the owner House's Factory indices will indicate what's
 		**	  being built.  (The player's sidebar also contains indices to indicate
 		**	  what's being built, but those just echo the house's indices.)
 		*/
 		if (Factory) {
 			Factory->Abandon();
 			delete Factory;
 			Factory = 0;
 		}
 
 		/*
 		** If the owner HouseClass is building something, and this building can
 		** build that thing, we may be the last building for that house that can
 		** build that thing; if so, abandon production of it.
 		*/
 		housep = HouseClass::As_Pointer(Owner());
 		if (housep) {
 			FactoryClass * factory = 0;
 			bld_type = RTTI_NONE;
 			if (housep->AircraftFactory != -1 && Class->ToBuild == RTTI_AIRCRAFTTYPE) {
 				bld_type = RTTI_AIRCRAFTTYPE;
 				factory = Factories.Raw_Ptr(housep->AircraftFactory);
 			}
 			if (housep->InfantryFactory != -1 && Class->ToBuild==RTTI_INFANTRYTYPE) {
 				bld_type = RTTI_INFANTRYTYPE;
 				factory = Factories.Raw_Ptr(housep->InfantryFactory);
 			}
 			if (housep->UnitFactory != -1 && Class->ToBuild==RTTI_UNITTYPE) {
 				bld_type = RTTI_UNITTYPE;
 				factory = Factories.Raw_Ptr(housep->UnitFactory);
 			}
 			if (housep->BuildingFactory != -1 && Class->ToBuild==RTTI_BUILDINGTYPE) {
 				bld_type = RTTI_BUILDINGTYPE;
 				factory = Factories.Raw_Ptr(housep->BuildingFactory);
 			}
 			if (housep->SpecialFactory != -1 && Class->ToBuild==RTTI_SPECIAL) {
 				bld_type = RTTI_SPECIAL;
 			}
 
 			if (bld_type != RTTI_NONE) {
 				if (factory) {
 					TechnoClass * object = factory->Get_Object();
 					IsInLimbo = true;
 					if (object && !object->Techno_Type_Class()->Who_Can_Build_Me(true, false, housep->Class->House)) {
 						housep->Abandon_Production(bld_type);
 					}
 					IsInLimbo = false;
 				}
 			}
 		}
 #endif
 
 		/*
 		**	This could be a building that builds. If so, then the sidebar may need adjustment.
 		** Set IsInLimbo to true to "fool" the sidebar into knowing that this building
 		** isn't available.  Set it back to false so the rest of the Limbo code works.
 		** Otherwise, the sidebar won't properly remove non-available buildables.
 		*/
 		if (IsOwnedByPlayer && !ScenarioInit) {
 			IsInLimbo = true;
 			Map.Recalc();
 			IsInLimbo = false;
 		}
 #ifdef NEVER
 		if (!House->IsHuman) {
 			Update_Specials();
 		}
 #endif
 
 	}
 	return(TechnoClass::Limbo());
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Fire_Coord -- Calculates the coordinate that projectile would appear.        *
  *                                                                                             *
  *    This routine is used to determine where a projectile would appear if this building       *
  *    were to fire. The location usually depends on the current rotation setting of the        *
  *    turret or else on the direction of the target that will be fired upon.                   *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with coordinate that the projectile should appear at if the building       *
  *          were to fire.                                                                      *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   12/24/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 FireDataType BuildingClass::Fire_Data(int ) const
 {
 	Validate();
 	COORDINATE coord = Center_Coord();
 	int dist = 0;
 
 	/*
 	**	Make adjustments to the firing coordinate to account for turret
 	**	position. This depends on building type and turret facing.
 	*/
 	switch (Class->Type) {
 		default:
 		case STRUCT_GTOWER:
 		case STRUCT_ATOWER:
 			coord = Coord_Move(coord, DIR_N, 0x0030);
 			dist = 0x0040;
 			break;
 		case STRUCT_OBELISK:
 			coord = Coord_Move(coord, DIR_N, 0x00A8);
 			coord = Coord_Move(coord, DIR_W, 0x0018);
 			break;
 
 		case STRUCT_SAM:
 		case STRUCT_TURRET:
 			coord = Coord_Move(coord, DIR_N, 0x0030);
 			dist = 0x0080;
 			break;
 	}
 
 	return{coord,dist};
 }
 
 
 COORDINATE BuildingClass::Fire_Coord(int ) const
 {
 	Validate();
 	COORDINATE coord = Center_Coord();			// Center of firing building.
 
 	/*
 	**	Make adjustments to the firing coordinate to account for turret
 	**	position. This depends on building type and turret facing.
 	*/
 	switch (Class->Type) {
 		default:
 		case STRUCT_GTOWER:
 		case STRUCT_ATOWER:
 			coord = Coord_Move(coord, DIR_N, 0x0030);
 			if (Target_Legal(TarCom)) {
 				coord = Coord_Move(coord, ::Direction(coord, As_Coord(TarCom)), 0x0040);
 			}
 			break;
 		case STRUCT_OBELISK:
 			coord = Coord_Move(coord, DIR_N, 0x00A8);
 //			coord = Coord_Move(coord, DIR_N, 0x0058);
 			coord = Coord_Move(coord, DIR_W, 0x0018);
 			break;
 
 		case STRUCT_SAM:
 		case STRUCT_TURRET:
 			coord = Coord_Move(coord, DIR_N, 0x0030);
 			coord = Coord_Move(coord, PrimaryFacing.Current(), 0x0080);
 			break;
 	}
 
 	return(coord);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Greatest_Threat -- Searches for target that building can fire upon.          *
  *                                                                                             *
  *    This routine intercepts the Greatest_Threat function so that it can add the ability      *
  *    to search for ground targets, if this isn't a SAM site.                                  *
  *                                                                                             *
  * INPUT:   threat   -- The base threat control value. Typically, it might be THREAT_RANGE     *
  *                      or THREAT_NORMAL.                                                      *
  *                                                                                             *
  * OUTPUT:  Returns with a suitable target. If none could be found, then TARGET_NONE is        *
  *          returned instead.                                                                  *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   01/01/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 TARGET BuildingClass::Greatest_Threat(ThreatType threat) const
 {
 	Validate();
 	if (*this != STRUCT_SAM) {
 		threat = threat | (THREAT_INFANTRY|THREAT_BOATS|THREAT_VEHICLES|THREAT_RANGE);
 
 		if (!House->IsHuman) {
 			threat = threat | THREAT_BUILDINGS;
 		}
 //		threat = threat & ~THREAT_AIR;
 	} else {
 		threat = threat | THREAT_AREA;
 	}
 
 	if (Class->Primary != WEAPON_NONE && BulletTypeClass::As_Reference(Weapons[Class->Primary].Fires).IsAntiAircraft) {
 		threat = threat | THREAT_AIR;
 	}
 	return(TechnoClass::Greatest_Threat(threat));
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Grand_Opening -- Handles construction completed special operations.          *
  *                                                                                             *
  *    This routine is called when construction has finished. Typically, this enables           *
  *    new production options for factories.                                                    *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   01/08/1995 JLB : Created.                                                                 *
  *   06/13/1995 JLB : Added helipad.                                                           *
  *=============================================================================================*/
 void BuildingClass::Grand_Opening(bool captured)
 {
 	Validate();
 
 	/*
 	**	Adjust the owning house according to the power, drain, and Tiberium capacity that
 	**	this building has.
 	*/
 	House->Adjust_Drain(Class->Drain);
 	House->Adjust_Capacity(Class->Capacity);
 	House->IsRecalcNeeded = true;
 
 	/*	SPECIAL CASE:
 	**	Refineries get a free harvester. Add a harvester to the reinforcement list
 	**	at this time.
 	*/
 	if (*this == STRUCT_REFINERY && !ScenarioInit && !captured && !Debug_Map && (!House->IsHuman || PurchasePrice == 0 || PurchasePrice > Class->Raw_Cost())) {
 		CELL cell = Coord_Cell(Adjacent_Cell(Center_Coord(), DIR_SW));
 //		if (!Map[cell].Cell_Unit()) {
 			UnitClass * unit = new UnitClass(UNIT_HARVESTER, House->Class->House);
 			if (unit) {
 
 				/*
 				**	Try to place down the harvesters. If it could not be placed, then try
 				**	to place it in a nearby location.
 				*/
 				if (!unit->Unlimbo(Cell_Coord(cell), DIR_SW)) {
 					cell = Nearby_Location(unit);
 
 					/*
 					**	If the harvester could still not be placed, then refund the money
 					**	to the owner and then bail.
 					*/
 					if (!unit->Unlimbo(Cell_Coord(cell), DIR_SW)) {
 						House->Refund_Money(unit->Class->Cost_Of());
 						delete unit;
 					}
 				}
 			} else {
 
 				/*
 				**	If the harvester could not be created in the first place, then give
 				**	the full refund price to the owning player.
 				*/
 				House->Refund_Money(UnitTypeClass::As_Reference(UNIT_HARVESTER).Cost_Of());
 			}
 		}
 //	}
 
 	/*
 	**	Helicopter pads get a free attack helicopter.
 	*/
 	if (*this == STRUCT_HELIPAD && !captured && (!House->IsHuman || PurchasePrice == 0 || PurchasePrice > Class->Raw_Cost())) {
 		ScenarioInit++;
 		AircraftClass * air = 0;
 		if (House->ActLike == HOUSE_GOOD) {
 			air = new AircraftClass(AIRCRAFT_ORCA, House->Class->House);
 		} else {
 			air = new AircraftClass(AIRCRAFT_HELICOPTER, House->Class->House);
 		}
 		if (air) {
 			air->Altitude = 0;
 			if (air->Unlimbo(Docking_Coord(), air->Pose_Dir())) {
 				air->Assign_Mission(MISSION_GUARD);
 				air->Transmit_Message(RADIO_HELLO, this);
 				Transmit_Message(RADIO_TETHER);
 			}
 		}
 		ScenarioInit--;
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Repair -- Initiates or terminates the repair process.                        *
  *                                                                                             *
  *    This routine will start, stop, or toggle the repair process. When a building repairs, it *
  *    occurs incrementally over time.                                                          *
  *                                                                                             *
  * INPUT:   control  -- Determines how to control the repair process.                          *
  *                      0: Turns repair process off (if it was on).                            *
  *                      1: Turns repair process on (if it was off).                            *
  *                      -1:Toggles repair process to other state.                              *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   01/08/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Repair(int control)
 {
 	Validate();
 	switch (control) {
 		case -1:
 			IsRepairing = (IsRepairing == false);
 			break;
 
 		case 1:
 			if (IsRepairing) return;
 			IsRepairing = true;
 			break;
 
 		case 0:
 			if (!IsRepairing) return;
 			IsRepairing = false;
 			break;
 	}
 
 	/*
 	**	At this point, we know that the repair state has changed. Perform
 	**	appropriate action.
 	*/
 	VocType sound = VOC_NONE;
 	if (IsRepairing) {
 		if (Strength == Class->MaxStrength) {
 			sound = VOC_SCOLD;
 		} else {
 			sound = VOC_BUTTON;
 			Clicked_As_Target(PlayerPtr->Class->House); // 2019/09/20 JAS - Added record of who clicked on the object
 			IsWrenchVisible = true;
 		}
 	} else {
 		sound = VOC_BUTTON;
 	}
 	//Changed for multiplayer ST - 3/13/2019 5:31PM
 	if (Is_Owned_By_Player()) {
 	//if (IsOwnedByPlayer) {
 		Sound_Effect(sound, Coord);
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Sell_Back -- Controls the sell back (demolish) operation.                    *
  *                                                                                             *
  *    This routine will initiate or stop the sell back process for a building. It is called    *
  *    when the player clicks on a building when the sell mode is active.                       *
  *                                                                                             *
  * INPUT:   control  -- The action to perform. 0 = turn deconstruction off, 1 = deconstruct,   *
  *                      -1 = toggle deconstruction state.                                      *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/25/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Sell_Back(int control)
 {
 	Validate();
 	if (Class->Get_Buildup_Data()) {
 		bool decon = false;
 		switch (control) {
 			case -1:
 				decon = (Mission != MISSION_DECONSTRUCTION);
 				break;
 
 			case 1:
 				if (Mission == MISSION_DECONSTRUCTION) return;
 				decon = true;
 				break;
 
 			case 0:
 				if (Mission != MISSION_DECONSTRUCTION) return;
 				decon = false;
 				break;
 		}
 
 		/*
 		**	At this point, we know that the repair state has changed. Perform
 		**	appropriate action.
 		*/
 		if (decon) {
 //			Transmit_Message(RADIO_RUN_AWAY);
 //			Transmit_Message(RADIO_OVER_OUT);
 			Assign_Mission(MISSION_DECONSTRUCTION);
 			//Changed for multiplayer ST - 3/13/2019 5:31PM
 			if (Is_Owned_By_Player()) {
 			//if (IsOwnedByPlayer) {
 				Clicked_As_Target(PlayerPtr->Class->House); // 2019/09/20 JAS - Added record of who clicked on the object
 			}
 		}
 		//Changed for multiplayer ST - 3/13/2019 5:31PM
 		if (Is_Owned_By_Player()) {
 		//if (IsOwnedByPlayer) {
 			Sound_Effect(VOC_BUTTON);
 		}
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::What_Action -- Determines action to perform if click on specified object.    *
  *                                                                                             *
  *    This routine will determine what action to perform if the mouse was clicked on the       *
  *    object specified. This determination is used to control the mouse imagery and the        *
  *    function process when the mouse button is pressed.                                       *
  *                                                                                             *
  * INPUT:   object   -- Pointer to the object that, if clicked on, will control what action    *
  *                      is to be performed.                                                    *
  *                                                                                             *
  * OUTPUT:  Returns with the ActionType that will occur if the mouse is clicked over the       *
  *          object specified while the building is currently selected.                         *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   01/18/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 ActionType BuildingClass::What_Action(ObjectClass * object) const
 {
 	Validate();
 	ActionType action = TechnoClass::What_Action(object);
 
 	if (action == ACTION_SELF) {
 		if (Class->IsFactory && PlayerPtr == House) {
 			switch (Class->ToBuild) {
 				case RTTI_AIRCRAFTTYPE:
 					if (House->AircraftFactories < 2) {
 						action = ACTION_NONE;
 					}
 					else {
 						action = ACTION_TOGGLE_PRIMARY;
 					}
 					break;
 
 				case RTTI_INFANTRYTYPE:
 					if (House->InfantryFactories < 2) {
 						action = ACTION_NONE;
 					}
 					else {
 						action = ACTION_TOGGLE_PRIMARY;
 					}
 					break;
 
 				case RTTI_UNITTYPE:
 					if (House->UnitFactories < 2) {
 						action = ACTION_NONE;
 					}
 					else {
 						action = ACTION_TOGGLE_PRIMARY;
 					}
 					break;
 
 				default:
 					action = ACTION_NONE;
 					break;
 			}
 
 		} else {
 			action = ACTION_NONE;
 		}
 	}
 
 	/*
 	**	Don't allow targeting of SAM sites, even if the CTRL key
 	**	is held down.
 	*/
 	if (action == ACTION_ATTACK && *this == STRUCT_SAM) {
 		action = ACTION_NONE;
 	}
 
 	if (action == ACTION_MOVE) {
 		action = ACTION_NONE;
 	}
 
 	return(action);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::What_Action -- Determines what action will occur.                            *
  *                                                                                             *
  *    This routine examines the cell specified and returns with the action that will be        *
  *    performed if that cell were clicked upon while the building is selected.                 *
  *                                                                                             *
  * INPUT:   cell  -- The cell to examine.                                                      *
  *                                                                                             *
  * OUTPUT:  Returns the ActionType that indicates what should occur if the mouse is clicked    *
  *          on this cell.                                                                      *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   01/18/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 ActionType BuildingClass::What_Action(CELL cell) const
 {
 	Validate();
 	ActionType action = TechnoClass::What_Action(cell);
 
 	if (action == ACTION_MOVE && (*this != STRUCT_CONST || !Special.IsMCVDeploy)) {
 		action = ACTION_NONE;
 	}
 
 	/*
 	**	Don't allow targeting of SAM sites, even if the CTRL key
 	**	is held down.
 	*/
 	if (action == ACTION_ATTACK && *this == STRUCT_SAM) {
 		action = ACTION_NONE;
 	}
 
 	return(action);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Begin_Mode -- Begins an animation mode for the building.                     *
  *                                                                                             *
  *    This routine will start the building animating. This animation will loop indefinately    *
  *    until explicitly stopped.                                                                *
  *                                                                                             *
  * INPUT:   bstate   -- The animation state to initiate.                                       *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   The buliding graphic state will reflect the first stage of this animation the   *
  *             very next time it is rendered.                                                  *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/25/1995 JLB : Created.                                                                 *
  *   07/02/1995 JLB : Uses normalize animation rate where applicable.                          *
  *=============================================================================================*/
 void BuildingClass::Begin_Mode(BStateType bstate)
 {
 	Validate();
 	QueueBState = bstate;
 	if (BState == BSTATE_NONE || bstate == BSTATE_CONSTRUCTION || ScenarioInit) {
 		BState = bstate;
 		QueueBState = BSTATE_NONE;
 		BuildingTypeClass::AnimControlType const * ctrl = Fetch_Anim_Control();
 
 		int rate = ctrl->Rate;
 		if (Class->IsRegulated && bstate != BSTATE_CONSTRUCTION) {
 			rate = Options.Normalize_Delay(rate);
 		}
 		Set_Rate(rate);
 		Set_Stage(ctrl->Start);
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Read_INI -- Reads buildings from INI file.                                   *
  *                                                                                             *
  *    This is the basic scenario initialization of building function. It                       *
  *    is called when reading the scenario startup INI file and it handles                      *
  *    creation of all specified buildings.                                                     *
  *                                                                                             *
  *    INI entry format:                                                                        *
  *      Housename, Typename, Strength, Cell, Facing, Triggername                               *
  *                                                                                             *
  * INPUT:   buffer   -- Pointer to the loaded INI file data.                                   *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   05/24/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Read_INI(char *buffer)
 {
 	BuildingClass			*b;			// Working unit pointer.
 	char						*tbuffer;	// Accumulation buffer of unit IDs.
 	HousesType				bhouse;		// Building house.
 	StructType				classid;		// Building type.
 	int						len;			// Size of data in buffer.
 	CELL						cell;			// Cell of building.
 	char						buf[128];
 	char						*trigname;	// building's trigger's name
 
 	len = strlen(buffer) + 2;
 	tbuffer = buffer + len;
 
 	/*
 	**	Read the entire building INI section into HIDBUF
 	*/
 	WWGetPrivateProfileString(INI_Name(), NULL, NULL, tbuffer, ShapeBufferSize-len, buffer);
 
 	while (*tbuffer != '\0') {
 
 		/*
 		**	Get a building entry.
 		*/
 		WWGetPrivateProfileString(INI_Name(), tbuffer, NULL, buf, sizeof(buf)-1, buffer);
 
 		/*
 		**	1st token: house name.
 		*/
 		bhouse = HouseTypeClass::From_Name(strtok(buf, ","));
 
 		/*
 		**	2nd token: building name.
 		*/
 		classid = BuildingTypeClass::From_Name(strtok(NULL, ","));
 
 		if (bhouse != HOUSE_NONE && classid != STRUCT_NONE) {
 			int	strength;
 			DirType facing;
 
 			/*
 			**	3rd token: strength.
 			*/
 			strength = atoi(strtok(NULL, ","));
 
 			/*
 			**	4th token: cell #.
 			*/
 			cell = atoi(strtok(NULL, ","));
 
 			/*
 			**	5th token: facing.
 			*/
 			facing = (DirType)atoi(strtok(NULL, ","));
 
 			/*
 			**	6th token: triggername (can be NULL).
 			*/
 			trigname = strtok(NULL,",");
 
 			if (HouseClass::As_Pointer(bhouse) != NULL) {
 				b = new BuildingClass(classid, bhouse);
 				if (b) {
 					if (b->Unlimbo(Cell_Coord(cell), facing)) {
 						strength = MIN(strength, 0x100);
 						strength = Fixed_To_Cardinal(b->Class->MaxStrength, strength);
 						b->Strength = strength;
 						b->IsALemon = false;
 						b->Trigger = TriggerClass::As_Pointer(trigname);
 						if (b->Trigger) {
 							b->Trigger->AttachCount++;
 						}
 					} else {
 
 						/*
 						**	If the building could not be unlimboed on the map, then this indicates
 						**	a serious error. Delete the building.
 						*/
 						delete b;
 					}
 				}
 			}
 		}
 		tbuffer += strlen(tbuffer)+1;
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Write_INI -- Writes all building data to an INI file.                        *
  *                                                                                             *
  *    This routine is used to write the buildings into an INI file. It is necessary for the    *
  *    scenario editor save game option.                                                        *
  *                                                                                             *
  *    INI entry format:                                                                        *
  *      Housename, Typename, Strength, Cell, Facing, Triggername                               *
  *                                                                                             *
  * INPUT:   buffer   -- The buffer that holds the INI data.                                    *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   05/28/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Write_INI(char *buffer)
 {
 	int			index;
 	char			uname[10];
 	char			buf[127];
 	char			*tbuffer;		// Accumulation buffer of unit IDs.
 
 	/*
 	**	First, clear out all existing building data from the ini file.
 	*/
 	tbuffer = buffer + strlen(buffer) + 2;
 	WWGetPrivateProfileString(INI_Name(), NULL, NULL, tbuffer, ShapeBufferSize-strlen(buffer), buffer);
 	while (*tbuffer != '\0') {
 		WWWritePrivateProfileString(INI_Name(), tbuffer, NULL, buffer);
 		tbuffer += strlen(tbuffer)+1;
 	}
 
 	/*
 	**	Write the data out.
 	*/
 	for (index = 0; index < Buildings.Count(); index++) {
 		BuildingClass * building;
 
 		building = Buildings.Ptr(index);
 		if (!building->IsInLimbo) {
 
 			sprintf(uname, "%03d", index);
 			sprintf(buf, "%s,%s,%d,%u,%d,%s",
 				building->House->Class->IniName,
 				building->Class->IniName,
 				building->Health_Ratio(),
 				Coord_Cell(building->Coord),
 				building->PrimaryFacing.Current(),
 				building->Trigger ? building->Trigger->Get_Name() : "None"
 				);
 			WWWritePrivateProfileString(INI_Name(), uname, buf, buffer);
 		}
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::As_Target -- Convert the building into a target value.                       *
  *                                                                                             *
  *    Use this routine to take the building and convert it into a target number.               *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns the target number for this building.                                       *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   03/10/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 TARGET BuildingClass::As_Target(void) const
 {
 	Validate();
 	return(Build_Target(KIND_BUILDING, Buildings.ID(this)));
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Center_Coord -- Fetches the center coordinate for the building.              *
  *                                                                                             *
  *    This routine is used to set the center coordinate for this building.                     *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the coordinate for the center location for the building.              *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   03/10/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 COORDINATE BuildingClass::Center_Coord(void) const
 {
 	Validate();
 	return(Coord_Add(Coord, CenterOffset[Class->Size]));
 }
 
 static bool Occupy_List_Contains(const short * list, short cell)
 {
 	while (*list != REFRESH_EOL) {
 		if (*list == cell) {
 			return true;
 		}
 		list++;
 	}
 	return false;
 }
 
 COORDINATE BuildingClass::Target_Coord(void) const
 {
 	static constexpr int _num_facings = 3;
 	static const FacingType _facings[_num_facings] = { FACING_S, FACING_E, FACING_SE };
 	static const COORDINATE _offsets[_num_facings] = { 0x00800000, 0x00000080, 0x00800080 };
 
 	Validate();
 	COORDINATE offset = CenterOffset[Class->Size];
 
 	const short * list = Occupy_List();
 	CELL cell = Coord_Cell(offset);
 	if (!Occupy_List_Contains(list, cell)) {
 		for (int i = 0; i < _num_facings; ++i) {
 			CELL adjcell = Adjacent_Cell(cell, _facings[i]);
 			if (Occupy_List_Contains(list, adjcell)) {
 				offset = Coord_Add(offset, _offsets[i]) & 0xFF80FF80;
 				break;
 			}
 		}
 	}
 	return(Coord_Add(Coord, offset));
 }
 
 
 COORDINATE BuildingClass::Docking_Coord(void) const
 {
 	Validate();
 	if (*this == STRUCT_HELIPAD) {
 		return(Coord_Add(Coord, XYP_COORD(24, 18)));
 	}
 	if (*this == STRUCT_AIRSTRIP) {
 		return(Coord_Add(Coord, XYP_COORD(18, 30)));
 	}
 	return(TechnoClass::Docking_Coord());
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Can_Fire -- Determines if this building can fire.                            *
  *                                                                                             *
  *    Use this routine to see if the building can fire its weapon.                             *
  *                                                                                             *
  *                                                                                             *
  * INPUT:   target   -- The target that firing upon is desired.                                *
  *                                                                                             *
  *          which    -- Which weapon to use when firing. 0=primary, 1=secondary.               *
  *                                                                                             *
  * OUTPUT:  Returns with the fire possibility code. If firing is allowed, then FIRE_OK is      *
  *          returned. Other cases will result in appropriate fire code value that indicates    *
  *          why firing is not allowed.                                                         *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   05/03/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 FireErrorType BuildingClass::Can_Fire(TARGET target, int which) const
 {
 	Validate();
 	FireErrorType canfire = TechnoClass::Can_Fire(target, which);
 
 	if (canfire == FIRE_OK) {
 
 		/*
 		**	Double check to make sure that the facing is roughly toward
 		**	the target. If the difference is too great, then firing is
 		**	temporarily postponed.
 		*/
 		if (Class->IsTurretEquipped) {
 			/*
 			**	If the turret is rotating then firing must be delayed.
 			*/
 			if (PrimaryFacing.Is_Rotating()) {
 				return(FIRE_ROTATING);
 			}
 
 			int diff = PrimaryFacing.Difference(Direction(TarCom));
 			if (ABS(diff) > 8) {
 				return(FIRE_FACING);
 			}
 		}
 
 		/*
 		**	Advanced guard towers need power to fire.
 		*/
 		if (*this == STRUCT_ATOWER && House->Power_Fraction() < 0x0100) {
 			return(FIRE_BUSY);
 		}
 
 		/*
 		** If an obelisk can fire, check the state of charge.  If it isn't charging
 		** up, start it charging up and return FIRE_BUSY.  If it is charging but
 		** isn't done yet, return FIRE_BUSY.  If it's done charging, stop the
 		** charging process, clear the stage timer, and return FIRE_OK.
 		*/
 		if (Class->Primary == WEAPON_OBELISK_LASER && !IsCharged) {
 			return(FIRE_BUSY);
 		}
 	}
 	return(canfire);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Toggle_Primary -- Toggles the primary factory state.                         *
  *                                                                                             *
  *    This routine will change the primary factory state of this building. The primary         *
  *    factory is the one that units will be produced from (by default).                        *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Is this building NOW the primary factory?                                          *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   05/03/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool BuildingClass::Toggle_Primary(void)
 {
 	Validate();
 	if (IsLeader) {
 		IsLeader = false;
 	} else {
 		for (int index = 0; index < Buildings.Count(); index++) {
 			BuildingClass * building = Buildings.Ptr(index);
 
 			if (!building->IsInLimbo && building->Owner() == Owner() && building->Class->ToBuild == Class->ToBuild) {
 				building->IsLeader = false;
 			}
 		}
 		IsLeader = true;
 		//
 		// MBL 07.22.2020 - Update so that each player in multiplayer will properly hear this when it applies to them
 		//
 		// if (House == PlayerPtr) {
 		// 	Speak(VOX_PRIMARY_SELECTED);
 		// }
 		if ((HouseClass *)House->IsHuman) {
 			Speak(VOX_PRIMARY_SELECTED, House);
 		}
 	}
 	Mark(MARK_CHANGE);
 	return(IsLeader);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Captured -- Captures the building.                                           *
  *                                                                                             *
  *    This routine will change the owner of the building. It handles updating any related      *
  *    game systems as a result. Factories are the most prone to have great game related        *
  *    consequences when captured. This could also affect the sidebar and building ownership.   *
  *                                                                                             *
  * INPUT:   newowner -- Pointer to the house that is now the new owner.                        *
  *                                                                                             *
  * OUTPUT:  Was the capture attempt successful?                                                *
  *                                                                                             *
  * WARNINGS:   Capturing could fail if the house is already owned by the one specified or      *
  *             the building isn't allowed to be captured.                                      *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   05/03/1995 JLB : Created.                                                                 *
  *   07/05/1995 JLB : Fixed production problem with capturing enemy buildings.                 *
  *=============================================================================================*/
 bool BuildingClass::Captured(HouseClass * newowner)
 {
 	Validate();
 	if (Can_Capture() && newowner != House) {
 		switch (Owner()) {
 			case HOUSE_GOOD:
 				Speak(VOX_GDI_CAPTURED);
 				break;
 
 			case HOUSE_BAD:
 				Speak(VOX_NOD_CAPTURED);
 				break;
 		}
 
 		if (House == PlayerPtr) {
 			Map.PowerClass::IsToRedraw = true;
 			Map.Flag_To_Redraw(false);
 		}
 
 		/*
 		** Maybe trigger an achivement. ST - 11/14/2019 1:53PM
 		*/
 		if (newowner->IsHuman) {
 			TechnoTypeClass const *object_type = Techno_Type_Class();
 			if (object_type) {
 				if (newowner->ActLike != House->ActLike) {
 					On_Achievement_Event(newowner, "OPPOSING_BUILDING_CAPTURED", object_type->IniName);
 				} else {
 					On_Achievement_Event(newowner, "BUILDING_CAPTURED", object_type->IniName);
 				}	
 			}
 		}
 
 		/*
 		** Add this building to the list of buildings captured this game. For internet stats purposes
 		*/
 		if (GameToPlay == GAME_INTERNET){
 			newowner->CapturedBuildings->Increment_Unit_Total (Class->Type);
 		}
 
 		House->Adjust_Power(-Power_Output());
 		LastStrength = 0;
 		House->Adjust_Drain(-Class->Drain);
 		int booty = House->Adjust_Capacity(-(int)Class->Capacity, true);
 
 		/*
 		**	If there is something loaded, then it gets captured as well.
 		*/
 		TechnoClass * tech = Attached_Object();
 		if (tech) tech->Captured(newowner);
 
 		/*
 		**	If something isn't technically attached, but is sitting on this
 		**	building for another reason (e.g., helicopter on helipad), then it
 		**	gets captured as well.
 		*/
 		tech = Contact_With_Whom();
 		if (tech) {
 			if (Transmit_Message(RADIO_NEED_TO_MOVE) == RADIO_ROGER && ::Distance(tech->Center_Coord(), Docking_Coord()) < 0x0040) {
 				tech->Captured(newowner);
 			} else {
 				Transmit_Message(RADIO_RUN_AWAY);
 				Transmit_Message(RADIO_OVER_OUT);
 			}
 		}
 
 		/*
 		**	Decrement the factory counter for the original owner.
 		*/
 		switch (Class->ToBuild) {
 			case RTTI_UNITTYPE:
 				House->UnitFactories--;
 				break;
 
 			case RTTI_INFANTRYTYPE:
 				House->InfantryFactories--;
 				break;
 
 			case RTTI_BUILDINGTYPE:
 				House->BuildingFactories--;
 				break;
 
 			case RTTI_AIRCRAFTTYPE:
 				House->AircraftFactories--;
 				break;
 
 			default:
 				break;
 		}
 
 #ifdef NEVER
 		if (IsOwnedByPlayer && !ScenarioInit) {
 			Map.Recalc();
 		}
 		if (!House->IsHuman) {
 			Update_Specials();
 		}
 #endif
 
 		/*
 		**	Flag that both owners now need to update their buildable lists.
 		*/
 		House->IsRecalcNeeded = true;
 		newowner->IsRecalcNeeded = true;
 
 		HouseClass * oldowner = House;				// Added for RA AI in TD. ST - 7/26/2019 9:25AM
 
 		IsCaptured = true;
 		TechnoClass::Captured(newowner);
 
 
 #ifdef USE_RA_AI
 		//
 		// Added for RA AI in TD. ST - 7/26/2019 9:25AM
 		//
 		oldowner->Recalc_Center();
 		House->Recalc_Center();
 #endif
 
 		SmudgeType bib;
 		CELL cell = Coord_Cell(Coord);
 		if (Class->Bib_And_Offset(bib, cell)) {
 			SmudgeClass * smudge = new SmudgeClass(bib);
 			if (smudge) {
 				smudge->Disown(cell);
 				delete smudge;
 			}
 			new SmudgeClass(bib, Cell_Coord(cell), House->Class->House);
 		}
 
 		/*
 		**	Increment the factory count for the new owner.
 		*/
 		switch (Class->ToBuild) {
 			case RTTI_UNITTYPE:
 				House->UnitFactories++;
 				break;
 
 			case RTTI_INFANTRYTYPE:
 				House->InfantryFactories++;
 				break;
 
 			case RTTI_BUILDINGTYPE:
 				House->BuildingFactories++;
 				break;
 
 			case RTTI_AIRCRAFTTYPE:
 				House->AircraftFactories++;
 				break;
 
 			default:
 				break;
 		}
 
 		IsRepairing = false;
 		Grand_Opening(true);
 		House->Harvested(booty);
 
 		Mark(MARK_CHANGE);
 
 		/*
 		**	Perform a look operation when catpured if it was the player
 		**	that performed the capture.
 		*/
 		if (GameToPlay == GAME_GLYPHX_MULTIPLAYER && House->IsHuman) {
 			Look(false);
 		} else {
 			if (House == PlayerPtr) {
 				Look(false);
 			}
 		}
 
 		if (oldowner) {
 			oldowner->Check_Pertinent_Structures();
 		}
 
 		return(true);
 	}
 	return(false);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Sort_Y -- Returns the building coordinate used for sorting.                  *
  *                                                                                             *
  *    The coordinate value returned from this function should be used for sorting purposes.    *
  *    It has special offset adjustment applied so that vehicles don't overlap (as much).       *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with a coordinate value suitable to be used for sorting.                   *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   05/23/1995 JLB : Created.                                                                 *
  *   06/19/1995 JLB : Handles buildings that come with bibs built-in.                          *
  *=============================================================================================*/
 COORDINATE BuildingClass::Sort_Y(void) const
 {
 	Validate();
 	if (*this == STRUCT_REPAIR) {
 		return(Coord);
 	}
 	if (*this == STRUCT_HELIPAD) {
 		return(Center_Coord());
 	}
 	if (*this == STRUCT_BARRACKS /*|| *this == STRUCT_POWER*/) {
 		return(Center_Coord());
 	}
 	if (*this == STRUCT_REFINERY) {
 		return(Center_Coord());
 	}
 	return(Coord_Add(Center_Coord(), XY_Coord(0, (Class->Height()*256)/3)));
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Can_Enter_Cell -- Determines if building can be placed down.                 *
  *                                                                                             *
  *    This routine will determine if the building can be placed down at the location           *
  *    specified.                                                                               *
  *                                                                                             *
  * INPUT:   cell  -- The cell to examine. This is usually the cell of the upper left corner    *
  *                   of the building if it were to be placed down.                             *
  *                                                                                             *
  * OUTPUT:  Returns with the move legality value for placement at the location specified. This *
  *          will either be MOVE_OK or MOVE_NO.                                                 *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/25/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 MoveType BuildingClass::Can_Enter_Cell(CELL cell, FacingType) const
 {
 	Validate();
 
 	if (*this == STRUCT_CONST && IsDown) {
 		return(Map[cell].Is_Generally_Clear() ? MOVE_OK : MOVE_NO);
 	}
 
 	return(Class->Legal_Placement(cell) ? MOVE_OK : MOVE_NO);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Can_Demolish -- Can the player demolish (sell back) the building?            *
  *                                                                                             *
  *    Determines if the player can sell this building. Selling is possible if the building     *
  *    is not currently in construction or deconstruction animation.                            *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Can the building be demolished at this time?                                       *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/25/1995 JLB : Created.                                                                 *
  *   07/01/1995 JLB : If there is no buildup data, then the building can't be sold.            *
  *   07/17/1995 JLB : Cannot sell a refinery that has a harvester attached.                    *
  *=============================================================================================*/
 bool BuildingClass::Can_Demolish(void) const
 {
 	Validate();
 	// !Mission !=  sounds a bit fishy. ST - 2018
 	//if (Class->Get_Buildup_Data() && BState != BSTATE_CONSTRUCTION && !Mission != MISSION_DECONSTRUCTION && Mission != MISSION_CONSTRUCTION) {
 	if (Class->IsUnsellable) return(false);
 	if (Class->Get_Buildup_Data() && BState != BSTATE_CONSTRUCTION && Mission != MISSION_DECONSTRUCTION && Mission != MISSION_CONSTRUCTION) {
 		if (*this == STRUCT_REFINERY && Is_Something_Attached()) return(false);
 		return(true);
 	}
 	return(false);
 }
 
 
 bool BuildingClass::Can_Demolish_Unit(void) const
 {
 	return(*this == STRUCT_REPAIR && In_Radio_Contact() && Distance(Contact_With_Whom()) < 0x0080);
 }
 
 
 bool BuildingClass::Can_Capture(void) const
 {
 	bool can_capture = Class->IsCaptureable && Mission != MISSION_DECONSTRUCTION;
 
 	// Override capturable state if this building has a capture win trigger
 	if (GameToPlay == GAME_NORMAL) {
 		if (!House->IsHuman && Trigger != NULL && Trigger->Action == TriggerClass::ACTION_WINLOSE) {
 			can_capture = true;
 		}
 	}
 
 	return(can_capture);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Mission_Guard -- Handles guard mission for combat buildings.                 *
  *                                                                                             *
  *    Buildings that can attack are given this mission. They will wait until a suitable target *
  *    comes within range and then launch into the attack mission. Buildings that have no       *
  *    weaponry will just sit in this routine forever.                                          *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the number of game frames to delay before this routine will be called *
  *          again.                                                                             *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/25/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 int BuildingClass::Mission_Guard(void)
 {
 	Validate();
 	/*
 	**	If this building has a weapon, then search for a target to attack. When
 	**	a target is found, switch into attack mode to deal with the threat.
 	*/
 	if (Class->Primary != WEAPON_NONE) {
 
 		/*
 		**	Weapon equipped buildings are ALWAYS ready to launch into another mission if
 		**	they are sitting around in guard mode.
 		*/
 		IsReadyToCommence = true;
 
 		/*
 		**	If there is no target available, then search for one.
 		*/
 		if (!Target_Legal(TarCom)) {
 			ThreatType threat = THREAT_NORMAL;
 			Assign_Target(Greatest_Threat(threat));
 		}
 
 		/*
 		**	There is a valid target. Switch into attack mode right away.
 		*/
 		if (Target_Legal(TarCom)) {
 			Assign_Mission(MISSION_ATTACK);
 			return(1);
 		}
 	} else {
 
 		/*
 		**	This is the very simple state machine that basically does
 		**	nothing. This is the mode that non weapon equipped buildings
 		**	are normally in.
 		*/
 		enum {
 			INITIAL_ENTRY,
 			IDLE
 		};
 		switch (Status) {
 			case INITIAL_ENTRY:
 				Begin_Mode(BSTATE_IDLE);
 				Status = IDLE;
 				break;
 
 			case IDLE:
 				/*
 				**	Special case to break out of guard mode if this is a repair
 				**	facility and there is a customer waiting at the grease pit.
 				*/
 				if (*this == STRUCT_REPAIR &&
 					In_Radio_Contact() &&
 					Contact_With_Whom()->Is_Techno() &&
 					((TechnoClass *)Contact_With_Whom())->Mission == MISSION_ENTER &&
 					Distance(Contact_With_Whom()) < 0x0040 &&
 					Transmit_Message(RADIO_NEED_TO_MOVE) == RADIO_ROGER) {
 
 					Assign_Mission(MISSION_REPAIR);
 					return(1);
 				}
 				break;
 		}
 		return(TICKS_PER_SECOND*5);
 	}
 	return(TICKS_PER_SECOND/2);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Mission_Construction -- Handles mission construction.                        *
  *                                                                                             *
  *    This routine will handle mission construction. When this mission is complete, the        *
  *    building will begin normal operation.                                                    *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the number of game frames to delay before calling this routine        *
  *          again.                                                                             *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/25/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 int BuildingClass::Mission_Construction(void)
 {
 	Validate();
 	enum {
 		INITIAL,
 		DURING
 	};
 	switch (Status) {
 		case INITIAL:
 			Begin_Mode(BSTATE_CONSTRUCTION);
 			Transmit_Message(RADIO_BUILDING);
 			//Changed for multiplayer ST - 3/13/2019 5:31PM
 			if (Is_Owned_By_Player()) {
 			//if (IsOwnedByPlayer) {
 				Sound_Effect(VOC_CONSTRUCTION, Coord);
 			}
 			Status = DURING;
 			break;
 
 		case DURING:
 			if (IsReadyToCommence) {
 
 				/*
 				**	When construction is complete, then transmit this
 				**	to the construction yard so that it can stop its
 				**	construction animation.
 				*/
 				Transmit_Message(RADIO_COMPLETE);		// "I'm finished."
 				Transmit_Message(RADIO_OVER_OUT);		// "You're free."
 				Begin_Mode(BSTATE_IDLE);
 				// Construction yard already called this on reveal in normal game mode, so don't do twice
 				if (*this != STRUCT_CONST || GameToPlay != GAME_NORMAL) {
 					Grand_Opening();
 				}
 				Assign_Mission(MISSION_GUARD);
 				PrimaryFacing = Class->StartFace;
 			}
 			break;
 	}
 	return(1);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Mission_Deconstruction -- Handles building deconstruction.                   *
  *                                                                                             *
  *    This state machine is only used when the building is deconstructing as a result of       *
  *    selling.  When this mission is finished, the building will no longer exist.              *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the number of game frames to delay before calling this routine again. *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/25/1995 JLB : Created.                                                                 *
  *   08/13/1995 JLB : Enable selling of units on a repair bay.                                 *
  *   08/20/1995 JLB : Scatters infantry from scattered starting points.                        *
  *=============================================================================================*/
 int BuildingClass::Mission_Deconstruction(void)
 {
 	Validate();
 	/*
 	**	Always force repair off.
 	*/
 	Repair(0);
 
 	enum {
 		INITIAL,
 		HOLDING,
 		DURING
 	};
 	switch (Status) {
 		case INITIAL:
 
 			/*
 			**	Special check for the repair bay which has the ability to sell
 			**	whatever is on it. If there is something on the repair bay, then
 			**	it will be sold. If there is nothing on the repair bay, then
 			**	the repair bay itself will be sold.
 			*/
 			if (Can_Demolish_Unit() && Transmit_Message(RADIO_NEED_TO_MOVE) == RADIO_ROGER) {
 				TechnoClass * tech = Contact_With_Whom();
 				Transmit_Message(RADIO_OVER_OUT);
 				tech->Sell_Back(1);
 //				House->Refund_Money(tech->Refund_Amount());
 //				tech->Limbo();
 				IsReadyToCommence = true;
 				Assign_Mission(MISSION_GUARD);
 				return(1);
 			}
 
 			IsReadyToCommence = false;
 			Transmit_Message(RADIO_RUN_AWAY);
 			Status = HOLDING;
 			break;
 
 		case HOLDING:
 			if (!IsTethered) {
 
 				/*
 				**	The crew will evacuate from the building. The number of crew
 				**	members leaving is equal to the unrecovered cost of the building
 				**	divided by 100 (the typical cost of a minigunner infantryman).
 				*/
 				if (!Target_Legal(ArchiveTarget) || !Special.IsMCVDeploy || *this != STRUCT_CONST) {
 					int divisor = 200;
 					if (IsCaptured) divisor *= 2;
 					int count = (Class->Raw_Cost()+(divisor-1)) / divisor;
 					bool engine = false;
 					count = Bound(count, 1, 5);
 
 					while (count) {
 
 						/*
 						**	Ensure that the player only gets ONE engineer and not from a captured
 						**	construction yard.
 						*/
 						InfantryType typ = Crew_Type();
 						while (typ == INFANTRY_E7 && engine) {
 							typ = Crew_Type();
 						}
 						if (typ == INFANTRY_E7) engine = true;
 
 						InfantryClass * infantry = new InfantryClass(typ, House->Class->House);
 						if (infantry) {
 							ScenarioInit++;
 							COORDINATE coord = Coord_Add(Center_Coord(), XYP_COORD(0, -12));
 							coord = Map[Coord_Cell(coord)].Closest_Free_Spot(coord, false);
 
 							if (infantry->Unlimbo(coord, DIR_N)) {
 								if (infantry->Class->IsNominal) infantry->IsTechnician = true;
 								ScenarioInit--;
 								infantry->Scatter(0, true);
 								ScenarioInit++;
 								infantry->Assign_Mission(MISSION_GUARD_AREA);
 							} else {
 								delete infantry;
 							}
 							ScenarioInit--;
 						}
 						count--;
 					}
 				}
 
 				// MBL 07.10.2020 - In 1v1, sometimes both players will hear this SFX, or neither player will hear it
 				// Making it so all players hear it positionally in the map; Per thread discussion in https://jaas.ea.com/browse/TDRA-7245
 				//
 				#if 0
 					//Changed for multiplayer ST - 3/13/2019 5:31PM
 					if (Is_Owned_By_Player()) {
 					//if (IsOwnedByPlayer) {
 						Sound_Effect(VOC_CASHTURN, Coord);
 					}
 				#else
 					Sound_Effect(VOC_CASHTURN, Coord);
 				#endif
 				
 				/*
 				**	Destroy all attached objects. ST - 4/24/2020 9:38PM
 				*/
 				while (Attached_Object()) {
 					FootClass * obj = Detach_Object();
 
 					Detach_All(true);
 					delete obj;
 				}
 				
 				Transmit_Message(RADIO_OVER_OUT);
 				Status = DURING;
 				Begin_Mode(BSTATE_CONSTRUCTION);
 				IsReadyToCommence = false;
 				IsSurvivorless = true;
 				break;
 			}
 			Transmit_Message(RADIO_RUN_AWAY);
 			break;
 
 		case DURING:
 			if (IsReadyToCommence) {
 
 				/*
 				**	Construction yards that deconstruct, really just revert back
 				**	to an MCV.
 				*/
 				if (Target_Legal(ArchiveTarget) && Special.IsMCVDeploy && *this == STRUCT_CONST && House->IsHuman) {
 					ScenarioInit++;
 					UnitClass * unit = new UnitClass(UNIT_MCV, House->Class->House);
 					ScenarioInit--;
 					if (unit) {
 
 						/*
 						**	Unlimbo the MCV onto the map. The MCV should start in the same
 						**	health condition that the construction yard was in.
 						*/
 						int ratio = Health_Ratio();
 						int money = Refund_Amount();
 						TARGET arch = ArchiveTarget;
 						COORDINATE place = Coord_Snap(Adjacent_Cell(Coord, DIR_SE));
 
 						Delete_This();
 
 						if (unit->Unlimbo(place, DIR_SW)) {
 							unit->Strength = Fixed_To_Cardinal(unit->Class_Of().MaxStrength, ratio);
 
 							/*
 							**	Lift the move destination from the building and assign
 							**	it to the unit.
 							*/
 							if (Target_Legal(arch)) {
 								unit->Assign_Destination(arch);
 								unit->Assign_Mission(MISSION_MOVE);
 							}
 						} else {
 
 							/*
 							**	If, for some strange reason, the MCV could not be placed on the
 							**	map, then give the player some money to compensate.
 							*/
 							House->Refund_Money(money);
 						}
 					} else {
 						House->Refund_Money(Refund_Amount());
 						Delete_This();
 					}
 
 				} else {
 
 					/*
 					**	A sold building still counts as a kill, but it just isn't directly
 					**	attributed to the enemy.
 					*/
 					WhoLastHurtMe = HOUSE_NONE;
 					Record_The_Kill(NULL);
 
 					/*
 					**	The player gets part of the money back for the sell.
 					*/
 					House->Refund_Money(Refund_Amount());
 					Limbo();
 
 					if (House) {
 						House->Check_Pertinent_Structures();
 					}
 
 					/*
 					**	Finally, delete the building from the game.
 					*/
 					Delete_This();
 				}
 				House->IsRecalcNeeded = true;
 			}
 			break;
 	}
 	return(1);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Mission_Attack -- Handles attack mission for building.                       *
  *                                                                                             *
  *    Buildings that can attack are processed by this attack mission state machine.            *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the number of game frames to delay before calling this routine        *
  *          again.                                                                             *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/25/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 int BuildingClass::Mission_Attack(void)
 {
 	Validate();
 	if (*this == STRUCT_SAM) {
 		switch (Status) {
 
 			/*
 			**	The launcher is underground and awaiting the acquisition of
 			**	a target.
 			*/
 			case SAM_UNDERGROUND:
 				IsReadyToCommence = true;
 				if (Target_Legal(TarCom)) {
 					Set_Rate(2);
 					Set_Stage(0);
 					Status = SAM_RISING;
 					return(1);
 				} else {
 					Assign_Mission(MISSION_GUARD);
 				}
 				break;
 
 			/*
 			**	The launcher is rising into the ready position so that it
 			**	may rotate to face the target.
 			*/
 			case SAM_RISING:
 				if (Fetch_Stage() == 15) {
 					Set_Rate(0);
 					PrimaryFacing = DIR_N;
 					if (!Target_Legal(TarCom)) {
 						Status = SAM_LOWERING;
 					} else {
 						Status = SAM_READY;
 					}
 				}
 				return(1);
 
 			/*
 			**	This is the target tracking state of the launcher. It will rotate
 			**	to face the current TarCom of the launcher.
 			*/
 			case SAM_READY:
 				if (!Target_Legal(TarCom) || !Is_Target_Aircraft(TarCom) || As_Aircraft(TarCom)->Altitude == 0) {
 					Assign_Target(TARGET_NONE);
 					Status = SAM_LOCKING;
 					return(TICKS_PER_SECOND);
 				} else {
 					if (!PrimaryFacing.Is_Rotating()) {
 						DirType facing = Direction(TarCom);
 						if (PrimaryFacing.Difference(facing)) {
 							PrimaryFacing.Set_Desired(facing);
 						} else {
 							Status = SAM_FIRING;
 						}
 					}
 				}
 				return(1);
 
 			/*
 			**	The launcher is in the process of firing.
 			*/
 			case SAM_FIRING:
 				if (!Target_Legal(TarCom) || !Is_Target_Aircraft(TarCom) || As_Aircraft(TarCom)->Altitude == 0) {
 					Assign_Target(TARGET_NONE);
 					Status = SAM_LOCKING;
 				} else {
 					FireErrorType error = Can_Fire(TarCom, 0);
 					if (error == FIRE_ILLEGAL || error == FIRE_CANT || error == FIRE_RANGE) {
 						Assign_Target(TARGET_NONE);
 						Status = SAM_LOCKING;
 					} else {
 						if (error == FIRE_FACING) {
 							Status = SAM_READY;
 						} else {
 							if (error == FIRE_OK) {
 								Fire_At(TarCom, 0);
 								Status = SAM_READY2;
 								return(1);
 							}
 						}
 					}
 				}
 				return(1);
 
 			case SAM_READY2:
 				if (!Target_Legal(TarCom) || !Is_Target_Aircraft(TarCom) || As_Aircraft(TarCom)->Altitude == 0) {
 					Assign_Target(TARGET_NONE);
 					Status = SAM_LOCKING;
 					return(TICKS_PER_SECOND);
 				} else {
 					if (!PrimaryFacing.Is_Rotating()) {
 						DirType facing = Direction(TarCom);
 						if (PrimaryFacing.Difference(facing)) {
 							PrimaryFacing.Set_Desired(facing);
 						} else {
 							Status = SAM_FIRING2;
 						}
 					}
 				}
 				return(1);
 
 			case SAM_FIRING2:
 				if (!Target_Legal(TarCom) || !Is_Target_Aircraft(TarCom) || As_Aircraft(TarCom)->Altitude == 0) {
 					Assign_Target(TARGET_NONE);
 					Status = SAM_LOCKING;
 				} else {
 					FireErrorType error = Can_Fire(TarCom, 0);
 					if (error == FIRE_ILLEGAL || error == FIRE_CANT || error == FIRE_RANGE) {
 						Assign_Target(TARGET_NONE);
 						Status = SAM_LOCKING;
 					} else {
 						if (error == FIRE_FACING) {
 							Status = SAM_READY2;
 						} else {
 							if (error == FIRE_OK) {
 								Fire_At(TarCom, 0);
 								Status = SAM_LOCKING;
 								return(TICKS_PER_SECOND*3);
 							}
 						}
 					}
 				}
 				return(1);
 
 			/*
 			**	Rotating to face north in preparation for lowering to reload.
 			*/
 			case SAM_LOCKING:
 				if (!PrimaryFacing.Is_Rotating()) {
 					if (PrimaryFacing == DIR_N) {
 						Set_Rate(2);
 						Set_Stage(48);
 						Status = SAM_LOWERING;
 					} else {
 						PrimaryFacing.Set_Desired(DIR_N);
 					}
 				}
 				return(1);
 
 			/*
 			**	Lowering into the ground in order to reload.
 			*/
 			case SAM_LOWERING:
 				if (Fetch_Stage() >= 63) {
 					Set_Rate(0);
 					Set_Stage(0);
 					Status = SAM_UNDERGROUND;
 					return(TICKS_PER_SECOND);
 				} else {
 					if (Fetch_Rate() == 0) {
 						Set_Rate(2);
 					}
 				}
 				return(1);
 
 			default:
 				break;
 		}
 
 	} else {
 		IsReadyToCommence = true;
 		switch (Can_Fire(TarCom, 0)) {
 			case FIRE_ILLEGAL:
 			case FIRE_CANT:
 			case FIRE_RANGE:
 			case FIRE_AMMO:
 				Assign_Target(TARGET_NONE);
 				Assign_Mission(MISSION_GUARD);
 				Commence();
 				break;
 
 			case FIRE_FACING:
 				PrimaryFacing.Set_Desired(Direction(TarCom));
 				return(2);
 
 			case FIRE_REARM:
 			case FIRE_BUSY:
 				return(1);
 
 			case FIRE_CLOAKED:
 				Do_Uncloak();
 				break;
 
 			case FIRE_OK:
 				Fire_At(TarCom, 0);
 				return(1);
 		}
 	}
 	return(TICKS_PER_SECOND);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Mission_Harvest -- Handles refinery unloading harvesters.                    *
  *                                                                                             *
  *    This state machine handles the refinery when it unloads the harvester.                   *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the number of game frames to delay before calling this routine        *
  *          again.                                                                             *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/25/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 int BuildingClass::Mission_Harvest(void)
 {
 	Validate();
 	enum {
 		INITIAL,					// Dock the Tiberium canister.
 		WAIT_FOR_DOCK,			// Waiting for docking to complete.
 		MIDDLE,					// Offload "bails" of tiberium.
 		WAIT_FOR_UNDOCK,		// Waiting for undocking to complete.
 		EXITING					// Cause the harvester to drive away.
 	};
 	switch (Status) {
 		case INITIAL:
 			Begin_Mode(BSTATE_ACTIVE);
 			Status = WAIT_FOR_DOCK;
 			break;
 
 		case WAIT_FOR_DOCK:
 			if (IsReadyToCommence) {
 				IsReadyToCommence = false;
 				Status = MIDDLE;
 				Begin_Mode(BSTATE_AUX1);
 			}
 			break;
 
 		case MIDDLE:
 			if (IsReadyToCommence) {
 				IsReadyToCommence = false;
 
 				/*
 				**	Force any bib squaters to scatter.
 				*/
 				bool old = Special.IsScatter;
 				Special.IsScatter = true;
 				Map[Adjacent_Cell(Coord_Cell(Center_Coord()), DIR_SW)].Incoming(0, true);
 				Special.IsScatter = old;
 
 				FootClass * techno = Attached_Object();
 				if (techno) {
 					int bail = techno->Offload_Tiberium_Bail();
 
 					if (bail) {
 						House->Harvested(bail);
 						if (techno->Tiberium_Load()) {
 							return(1);
 						}
 					}
 				}
 				Begin_Mode(BSTATE_AUX2);
 				Status = WAIT_FOR_UNDOCK;
 			}
 			break;
 
 		case WAIT_FOR_UNDOCK:
 			if (IsReadyToCommence) {
 
 				/*
 				**	Detach harvester and go back into idle state.
 				*/
 				Exit_Object(Detach_Object());
 				Assign_Mission(MISSION_GUARD);
 			}
 			break;
 	}
 	return(1);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Mission_Repair -- Handles the repair (active) state for building.            *
  *                                                                                             *
  *    This state machine is used when the building is active in some sort of repair or         *
  *    construction mode. The construction yard will animate. The repair facility will repair   *
  *    anything that it docked on it.                                                           *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the number of game frames to delay before calling this routine again. *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/25/1995 JLB : Created.                                                                 *
  *   06/25/1995 JLB : Handles repair facility                                                  *
  *   07/29/1995 JLB : Repair rate is controlled by power rating.                               *
  *=============================================================================================*/
 int BuildingClass::Mission_Repair(void)
 {
 	Validate();
 	if (*this == STRUCT_CONST) {
 		enum {
 			INITIAL,
 			DURING
 		};
 		switch (Status) {
 			case INITIAL:
 				Begin_Mode(BSTATE_ACTIVE);
 				Status = DURING;
 				break;
 
 			case DURING:
 				if (!In_Radio_Contact()) {
 					Assign_Mission(MISSION_GUARD);
 				}
 				break;
 		}
 		return(1);
 	}
 
 	if (*this == STRUCT_REPAIR) {
 		enum {
 			INITIAL,
 			IDLE,
 			DURING
 		};
 		switch (Status) {
 			case INITIAL:
 				if (!In_Radio_Contact()) {
 					Begin_Mode(BSTATE_IDLE);
 					Assign_Mission(MISSION_GUARD);
 					return(1);
 				}
 				IsReadyToCommence = false;
 				if (Transmit_Message(RADIO_NEED_TO_MOVE) == RADIO_ROGER && Distance(Contact_With_Whom()) < 0x0010) {
 					Status = IDLE;
 					return(TICKS_PER_SECOND/4);
 				}
 				break;
 
 			case IDLE:
 				if (!In_Radio_Contact()) {
 					Assign_Mission(MISSION_GUARD);
 					return(1);
 				}
 
 				if (Transmit_Message(RADIO_NEED_TO_MOVE) == RADIO_ROGER) {
 					if (Contact_With_Whom()->Health_Ratio() < 0x0100 && Transmit_Message(RADIO_REPAIR) == RADIO_ROGER) {
 
 						// MBL 07.06.2020 - Patch 3: Change to TD Legacy: Adding "Repairing" VO for units on repair bay
 						// Per https://jaas.ea.com/browse/TDRA-7271
 						if (IsOwnedByPlayer && House) Speak(VOX_REPAIRING, House);
 
 						Status = DURING;
 						Begin_Mode(BSTATE_ACTIVE);
 						IsReadyToCommence = false;
 					} else {
 						if (!House->IsHuman) {
 							Transmit_Message(RADIO_RUN_AWAY);
 						}
 					}
 //				} else {
 //					Assign_Mission(MISSION_GUARD);
 //					return(1);
 				}
 				break;
 
 			case DURING:
 				if (!In_Radio_Contact()) {
 					Begin_Mode(BSTATE_IDLE);
 					Status = IDLE;
 					return(1);
 				}
 				if (IsReadyToCommence && Transmit_Message(RADIO_NEED_TO_MOVE) == RADIO_ROGER) {
 					IsReadyToCommence = false;
 					long param = Health_Ratio();
 					if (Transmit_Message(RADIO_REPAIR, param) != RADIO_ROGER) {
 #ifdef OBSOLETE
 						if (House->Available_Money() < 10) {
 							Transmit_Message(RADIO_RUN_AWAY);
 						}
 #endif
 						Begin_Mode(BSTATE_IDLE);
 						Status = IDLE;
 #ifdef OBSOLETE
 					} else {
 						int time = Bound(Fixed_To_Cardinal(TICKS_PER_SECOND, House->Power_Fraction()), 0, TICKS_PER_SECOND);
 						time = (TICKS_PER_SECOND + (TICKS_PER_SECOND/2)) - time;
 						return(time);
 #endif
 					}
 				}
 				break;
 		}
 		return(TICKS_PER_SECOND/2);
 	}
 
 	if (*this == STRUCT_HELIPAD) {
 		enum {
 			INITIAL,
 			DURING
 		};
 		switch (Status) {
 			case INITIAL:
 				if (Transmit_Message(RADIO_NEED_TO_MOVE) == RADIO_ROGER && Transmit_Message(RADIO_PREPARED) == RADIO_NEGATIVE) {
 					Begin_Mode(BSTATE_ACTIVE);
 					Contact_With_Whom()->Assign_Mission(MISSION_SLEEP);
 					Status = DURING;
 					return(1);
 				}
 				Assign_Mission(MISSION_GUARD);
 				break;
 
 			case DURING:
 				if (IsReadyToCommence) {
 					if (!In_Radio_Contact() || Transmit_Message(RADIO_NEED_TO_MOVE) == RADIO_NEGATIVE) {
 						Assign_Mission(MISSION_GUARD);
 						return(1);
 					}
 
 					if (Transmit_Message(RADIO_PREPARED) == RADIO_ROGER) {
 						Contact_With_Whom()->Assign_Mission(MISSION_GUARD);
 						Assign_Mission(MISSION_GUARD);
 						return(1);
 					}
 
 					if (Transmit_Message(RADIO_RELOAD) != RADIO_ROGER) {
 						Assign_Mission(MISSION_GUARD);
 						Contact_With_Whom()->Assign_Mission(MISSION_GUARD);
 						return(1);
 					} else {
 						int time = Bound(Fixed_To_Cardinal(TICKS_PER_SECOND, House->Power_Fraction()), 0, TICKS_PER_SECOND);
 						time = (TICKS_PER_SECOND*3) - time;
 						IsReadyToCommence = false;
 						return(time);
 					}
 				}
 				break;
 		}
 		return(3);
 	}
 	return(TICKS_PER_SECOND);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Mission_Missile -- State machine for nuclear missile launch.                 *
  *                                                                                             *
  *    This handles the Temple of Nod launching its nuclear missile.                            *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the number of frames to delay before calling this routine again.      *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/04/1995 JLB : Commented.                                                               *
  *=============================================================================================*/
 int BuildingClass::Mission_Missile(void)
 {
 	Validate();
 	enum {
 		INITIAL,
 		DOOR_OPENING,
 		LAUNCH_UP,
 		LAUNCH_DOWN,
 		DONE_LAUNCH
 	};
 
 	if (*this == STRUCT_TEMPLE) {
 		switch (Status) {
 
 			/*
 			** The initial case is responsible for starting the door
 			** opening on the building.
 			*/
 			case INITIAL:
 				IsReadyToCommence = false;
 				Begin_Mode(BSTATE_ACTIVE);
 				Status = DOOR_OPENING;
 				return(1);
 
 			/*
 			** This polls for the case when the door is actually open and
 			** then kicks off the missile smoke.
 			*/
 			case DOOR_OPENING:
 				if (IsReadyToCommence) {
 					Begin_Mode(BSTATE_IDLE);
 					new AnimClass(ANIM_ATOM_DOOR, Center_Coord());
 					Status = LAUNCH_UP;
 					return(14);
 				}
 				return(1);
 
 			/*
 			** Once the smoke has been going for a little while this
 			** actually handles launching the missile into the air.
 			*/
 			case LAUNCH_UP:
 				{
 					BulletClass *bullet = new BulletClass(BULLET_NUKE_UP);
 					if (bullet) {
 						COORDINATE launch = Coord_Move(Center_Coord(), (DirType)1, 0x1A0);
 						bullet->Assign_Target(TARGET_NONE);
 						bullet->Payback = NULL;
 						bullet->Strength = 1;
 						if (!bullet->Unlimbo(launch, DIR_N)) {
 							delete bullet;
 							bullet = NULL;
 						} else {
 							bullet->PrimaryFacing.Set_Current(DIR_N);
 							Sound_Effect(VOC_NUKE_FIRE, launch);
 
 							// MBL 03.27.2020 This is never getting triggered for any player in multiplayer, so removing the check (https://jaas.ea.com/browse/TDRA-5458)
 							// if (House == PlayerPtr) 
 							{
 								Speak(VOX_NUKE_LAUNCHED); // "NUKLNCH1" - "Nuclear Weapon Launched"
 							}
 						}
 					}
 
 					if (bullet) {
 						Status = LAUNCH_DOWN;
 						return(8 * TICKS_PER_SECOND);
 					}
 				}
 				return(1);
 
 			/*
 			** Once the missile is in the air, this handles waiting for
 			** the missile to be off the screen and then launching one down
 			** over the target.
 			*/
 			case LAUNCH_DOWN:
 				{
 				 	BulletClass *bullet = new BulletClass(BULLET_NUKE_DOWN);
 					if (bullet) {
 //						Theme.Queue_Song(THEME_NONE);
 						COORDINATE start = Cell_Coord(XY_Cell(Cell_X(House->NukeDest), 1));
 						bullet->Assign_Target(::As_Target(House->NukeDest));
 
 						// MBL 05.20.2020
 						// Fix for Nuke or Atom Bomb killing structures and units during animation sequence and not getting kills tracked
 						// Per https://jaas.ea.com/browse/TDRA-6610
 						//
 						// bullet->Payback = NULL;
 						bullet->Payback = this;
 
 						bullet->Strength = 1;
 						if (!bullet->Unlimbo(start, DIR_S)) {
 							delete bullet;
 						} else {
 							bullet->PrimaryFacing.Set_Current(DIR_S);
 						}
 						Speak(VOX_INCOMING_NUKE); // "Nuclear Warhead Approaching" - "NUKE1"
 						Sound_Effect(VOC_NUKE_FIRE, start);
 					}
 					if (bullet) {
 						Status = DONE_LAUNCH;
 						return(7 * TICKS_PER_SECOND);
 					}
 				}
 				return(1);
 
 			/*
 			** Once the missile is done launching this handles allowing
 			** the building to sit there with its door open.
 			*/
 			case DONE_LAUNCH:
 				Assign_Mission(MISSION_GUARD);
 				return(60);
 		}
 	}
 	return(60);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Revealed -- Reveals the building to the specified house.                     *
  *                                                                                             *
  *    This routine will reveal the building to the specified house. It will handle updating    *
  *    the sidebar for player owned buildings. A player owned building that hasn't been         *
  *    revealed, is in a state of pseudo-limbo. It cannot be used for any of its special        *
  *    abilities even though it exists on the map for all other purposes.                       *
  *                                                                                             *
  * INPUT:   house -- The house that this building is being revealed to.                        *
  *                                                                                             *
  * OUTPUT:  Was this building revealed by this procedure?                                      *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/25/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool BuildingClass::Revealed(HouseClass * house)
 {
 	Validate();
 	if (TechnoClass::Revealed(house)) {
 
 		if (!ScenarioInit) {
 			House->JustBuilt = Class->Type;
 		}
 		House->IsRecalcNeeded = true;
 
 		/*
 		**	Perform any grand opening here so that in the scenarios where a player
 		**	owned house is not yet revealed, it won't be reflected in the sidebar
 		**	selection icons.
 		*/
 		/*
 		** Making a change here to avoid Grand_Opening happening multiple times in MP/skirmish. ST - 7/26/2019 11:26AM
 		*/
 		//if (!In_Radio_Contact() && (house == House || GameToPlay != GAME_NORMAL) && Mission != MISSION_CONSTRUCTION) {
 		if (!In_Radio_Contact() && (house == House && GameToPlay == GAME_NORMAL) && Mission != MISSION_CONSTRUCTION) {
 			Grand_Opening();
 		}
 
 		return(true);
 	}
 	return(false);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Enter_Idle_Mode -- The building will enter its idle mode.                    *
  *                                                                                             *
  *    This routine is called when the exact mode of the building isn't known. By examining     *
  *    the building's condition, this routine will assign an appropriate mission.               *
  *                                                                                             *
  * INPUT:   initial  -- This this being called during scenario init?                           *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/25/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Enter_Idle_Mode(bool initial)
 {
 	Validate();
 	/*
 	**	Assign an appropriate mission for the building. If the ScenarioInit flag is true, then
 	**	this must be an initial building. Start such buildings in idle state. For other buildings
 	**	it indicates that it is being placed during game play and thus it must start in
 	**	the "construction" mission.
 	*/
 	MissionType mission = MISSION_GUARD;
 	if (!initial || ScenarioInit || Debug_Map) {
 		Begin_Mode(BSTATE_IDLE);
 		mission = MISSION_GUARD;
 	} else {
 		Begin_Mode(BSTATE_CONSTRUCTION);
 		mission = MISSION_CONSTRUCTION;
 	}
 	Assign_Mission(mission);
 }
 
 
 /***************************************************************************
  * BuildingClass::Update_Specials -- removes computer specials             *
  *                                                                         *
  *                                                                         *
  *                                                                         *
  * INPUT:                                                                  *
  *                                                                         *
  * OUTPUT:                                                                 *
  *                                                                         *
  * WARNINGS:                                                               *
  *                                                                         *
  * HISTORY:                                                                *
  *   06/21/1995 PWG : Created.                                             *
  *=========================================================================*/
 void BuildingClass::Update_Specials(void)
 {
 	Validate();
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Pip_Count -- Determines "full" pips to display for building.                 *
  *                                                                                             *
  *    This routine will determine the number of pips that should be filled in when rendering   *
  *    the building.                                                                            *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns the number of pips to display as filled in.                                *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/28/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 int BuildingClass::Pip_Count(void) const
 {
 	Validate();
 	return(Fixed_To_Cardinal(Class->Max_Pips(), House->Tiberium_Fraction()));
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Death_Announcement -- Announce the death of this building.                   *
  *                                                                                             *
  *    This routine is called when the building is destroyed by "unnatural" means. Typically    *
  *    as a result of combat. If the building is known to the player, then it should be         *
  *    announced.                                                                               *
  *                                                                                             *
  * INPUT:   source   -- The object most directly responsible for the building's death.         *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/04/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Death_Announcement(TechnoClass const * ) const
 {
 	Validate();
 	//Changed for multiplayer ST - 3/13/2019 5:31PM
 	if (Is_Discovered_By_Player() || Is_Owned_By_Player()) {
 	//if (IsDiscoveredByPlayer || IsOwnedByPlayer) {
 		if (House != PlayerPtr && GameToPlay != GAME_NORMAL) {
 			if (Options.IsDeathAnnounce) Speak(VOX_ENEMY_STRUCTURE);
 		} else {
 			if (House == PlayerPtr || Options.IsDeathAnnounce) {
 				if (!Options.IsDeathAnnounce) {
 					Speak(VOX_STRUCTURE_LOST);
 				} else {
 					switch (House->ActLike) {
 						case HOUSE_GOOD:
 							Speak(VOX_GDI_STRUCTURE);
 							break;
 
 						case HOUSE_BAD:
 							Speak(VOX_NOD_STRUCTURE);
 							break;
 
 						default:
 							break;
 					}
 				}
 			}
 		}
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Fire_Direction -- Fetches the direction of firing.                           *
  *                                                                                             *
  *    This routine will return with the default direction to use when firing from this         *
  *    building. This is the facing of the turret except for the case of non-turret equipped    *
  *    buildings that have a weapon (e.g., guard tower).                                        *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the default firing direction for this building.                       *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/04/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 DirType BuildingClass::Fire_Direction(void) const
 {
 	Validate();
 	if (Class->IsTurretEquipped) {
 		return(PrimaryFacing.Current());
 	}
 	return(Direction(TarCom));
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Remap_Table -- Fetches the remap table to use for this building.             *
  *                                                                                             *
  *    Use this routine to fetch the remap table to use.  This override function is needed      *
  *    because the default remap table for techno objects presumes the object is a unit.        *
  *    Buildings aren't units.                                                                  *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the proper remap table to use for this building.                      *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/08/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 void const * BuildingClass::Remap_Table(void)
 {
 	Validate();
 	return(House->Remap_Table(IsBlushing, false));
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Mission_Unload -- Handles the unload mission for a building.                 *
  *                                                                                             *
  *    This is the unload mission for a building. This really only applies to the weapon's      *
  *    factory, since it needs the sophistication of an unload mission due to the door          *
  *    animation.                                                                               *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the number of game frames to delay before calling this routine        *
  *          again.                                                                             *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/29/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 int BuildingClass::Mission_Unload(void)
 {
 	Validate();
 	if (*this == STRUCT_WEAP) {
 		COORDINATE coord = Adjacent_Cell(Center_Coord(), FACING_SW);
 		CELL cell = Coord_Cell(coord);
 		CellClass * cellptr = &Map[cell];
 		enum {
 			INITIAL,
 			CLEAR_BIB,
 			OPEN,
 			LEAVE,
 			CLOSE
 		};
 		UnitClass * unit;
 		switch (Status) {
 			case INITIAL:
 				unit = (UnitClass *)Contact_With_Whom();
 				if (unit) {
 					unit->Assign_Mission(MISSION_GUARD);
 					unit->Commence();
 				}
 				Open_Door(2, 11);
 				Status = CLEAR_BIB;
 				break;
 
 			/*
 			**	Now that the occupants can peek out the door, they will tell
 			**	everyone that could be blocking the way, that they should
 			**	scatter away.
 			*/
 			case CLEAR_BIB:
 				unit = (UnitClass *)Contact_With_Whom();
 				if (cellptr->Cell_Unit() || cellptr->Cell_Infantry()) {
 					cellptr->Incoming(0, true, true);
 
 					/*
 					**	Scatter everything around the weapon's factory door.
 					*/
 					for (FacingType f = FACING_FIRST; f < FACING_COUNT; f++) {
 						CellClass * cptr = cellptr->Adjacent_Cell(f);
 						if (!cptr) continue;
 						UnitClass * cellunit = cptr->Cell_Unit();
 						if ((cellunit && cellunit != unit) || cptr->Cell_Infantry()) {
 							cptr->Incoming(coord, true, true);
 						}
 					}
 				} else {
 					Status = OPEN;
 				}
 				break;
 
 			case OPEN:
 				if (Is_Door_Open()) {
 					unit = (UnitClass *)Contact_With_Whom();
 					if (unit) {
 						unit->Assign_Mission(MISSION_MOVE);
 						unit->Force_Track(DriveClass::OUT_OF_WEAPON_FACTORY, Adjacent_Cell(Center_Coord(), FACING_SW));
 						unit->Set_Speed(128);
 						Status = LEAVE;
 					} else {
 						Close_Door(2, 11);
 						Status = CLOSE;
 					}
 				}
 				break;
 
 			case LEAVE:
 				if (!IsTethered) {
 					Close_Door(2, 11);
 					Status = CLOSE;
 				}
 				break;
 
 			case CLOSE:
 				if (Is_Door_Closed()) {
 					Enter_Idle_Mode();
 				}
 				break;
 		}
 		return(TICKS_PER_SECOND/2);
 	}
 	Assign_Mission(MISSION_GUARD);
 	return(TICKS_PER_SECOND);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Power_Output -- Fetches the current power output from this building.         *
  *                                                                                             *
  *    This routine will return the current power output for this building. The power output    *
  *    is adjusted according to the damage level of the building.                               *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns the current power output for this building.                                *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/29/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 int BuildingClass::Power_Output(void) const
 {
 	Validate();
 	if (Class->Power) {
 		return(Fixed_To_Cardinal(Class->Power, Cardinal_To_Fixed(Class->MaxStrength, LastStrength)));
 	}
 	return(0);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Detach -- Handles target removal from the game system.                       *
  *                                                                                             *
  *    This routine is called when the specified target is about to be removed from the game    *
  *    system.                                                                                  *
  *                                                                                             *
  * INPUT:   target   -- The target to be removed from this building's targeting computer.      *
  *                                                                                             *
  *          all      -- Is the target about to be completely eliminated?                       *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/29/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Detach(TARGET target, bool all)
 {
 	Validate();
 	TechnoClass::Detach(target, all);
 	if (target == WhomToRepay) {
 		WhomToRepay = TARGET_NONE;
 	}
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Refund_Amount -- Fetches the refund amount if building is sold.              *
  *                                                                                             *
  *    This routine will return the amount of money to be refunded to the building's owner      *
  *    if the building is sold.                                                                 *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the refund amount available for this building.                        *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/29/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 int BuildingClass::Refund_Amount(void) const
 {
 	Validate();
 	int cost = TechnoClass::Refund_Amount();
 
 	/*
 	**	Add in any Tiberium that was stored within the building.
 	*/
 	if (IsV107 && Class->Capacity > 0) {
 		cost += Fixed_To_Cardinal(Class->Capacity, Cardinal_To_Fixed(House->Capacity, House->Tiberium));
 	}
 	return(cost);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Crew_Type -- This determines the crew that this object generates.            *
  *                                                                                             *
  *    When selling very cheap buildings (such as the silo), a technician will pop out since    *
  *    generating minigunners would be overkill -- the player could use this loophole to        *
  *    gain an advantage.                                                                       *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns the infantry type that this building will generate as a survivor.          *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   08/05/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 InfantryType BuildingClass::Crew_Type(void) const
 {
 	Validate();
 	switch (Class->Type) {
 		case STRUCT_STORAGE:
 			if (Random_Pick(0, 1) == 0) {
 				return(INFANTRY_C1);
 			} else {
 				return(INFANTRY_C7);
 			}
 
 		case STRUCT_CONST:
 			if (!IsCaptured && House->IsHuman && Random_Pick(0, 3) == 0) {
 				return(INFANTRY_E7);
 			}
 			break;
 
 		default:
 			break;
 	}
 	return(TechnoClass::Crew_Type());
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Detach_All -- Possibly abandons production according to factory type.        *
  *                                                                                             *
  *    When this routine is called, it indicates that the building is about to be destroyed     *
  *    or captured. In such a case any production it may be doing, must be abandoned.           *
  *                                                                                             *
  * INPUT:   all   -- Is the object about the be completely destroyed?                          *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   08/05/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 void BuildingClass::Detach_All(bool all)
 {
 	Validate();
 	/*
 	**	If it is producing something, then it must be abandoned.
 	*/
 	if (Factory) {
 		Factory->Abandon();
 		delete Factory;
 		Factory = 0;
 	}
 
 	/*
 	** If the owner HouseClass is building something, and this building can
 	** build that thing, we may be the last building for that house that can
 	** build that thing; if so, abandon production of it.
 	*/
 	if (House) {
 		int fnum = -1;
 
 		switch (Class->ToBuild) {
 			case RTTI_AIRCRAFTTYPE:
 				fnum = House->AircraftFactory;
 				break;
 
 			case RTTI_INFANTRYTYPE:
 				fnum = House->InfantryFactory;
 				break;
 
 			case RTTI_UNITTYPE:
 				fnum = House->UnitFactory;
 				break;
 
 			case RTTI_BUILDINGTYPE:
 				fnum = House->BuildingFactory;
 				break;
 
 			case RTTI_SPECIAL:
 				fnum = House->SpecialFactory;
 				break;
 
 		}
 
 		/*
 		**	Convert the factory number into a real factory pointer.
 		*/
 		FactoryClass * factory = 0;
 		if (fnum != -1) {
 			factory = Factories.Raw_Ptr(fnum);
 		}
 
 		/*
 		**	If a factory was found, then temporarily disable this building and then
 		**	detmermine if any object that is being produced can still be produced. If
 		**	not, then the object being produced must be abandoned.
 		*/
 		if (factory) {
 			TechnoClass * object = factory->Get_Object();
 			IsInLimbo = true;
 			if (object && !object->Techno_Type_Class()->Who_Can_Build_Me(true, false, House->Class->House)) {
 				House->Abandon_Production(Class->ToBuild);
 			}
 			IsInLimbo = false;
 		}
 	}
 
 	TechnoClass::Detach_All(all);
 }
 
 
 /***********************************************************************************************
  * BuildingClass::Flush_For_Placement -- Handles clearing a zone for object placement.         *
  *                                                                                             *
  *    This routine is used to clear the way for placement of the specified object (usually     *
  *    a building). If there are friendly units blocking the placement area, they are told      *
  *    to scatter. Enemy blocking units are attacked.                                           *
  *                                                                                             *
  * INPUT:   techno   -- Pointer to the object that is desired to be placed.                    *
  *                                                                                             *
  *          cell     -- The cell that placement wants to occur at.                             *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   08/06/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool BuildingClass::Flush_For_Placement(TechnoClass * techno, CELL cell)
 {
 	Validate();
 	bool again = false;
 	if (techno && cell > 0) {
 		short const * list = techno->Class_Of().Occupy_List(true);
 
 		while (*list != REFRESH_EOL) {
 			CELL newcell = cell + *list++;
 
 			if (Map.In_Radar(newcell)) {
 				TechnoClass * occupier = Map[newcell].Cell_Techno();
 				if (occupier) {
 					again = true;
 					if (occupier->House->Is_Ally(this)) {
 						Map[newcell].Incoming(0, true);
 					} else {
 						Base_Is_Attacked(occupier);
 					}
 				}
 			}
 		}
 	}
 	return(again);
 }
 
 
 void BuildingClass::Hidden(void)
 {
 //	if (IsDiscoveredByPlayer && House->IsHuman) {
 //		House->Adjust_Drain(-Class->Drain);
 //	}
 	TechnoClass::Hidden();
 }
 
 
 CELL BuildingClass::Find_Exit_Cell(TechnoClass const * techno) const
 {
 	CELL const *ptr;
 	CELL origin = Coord_Cell(Coord);
 	bool found = false;
 
 	ptr = Class->ExitList;
 	if (ptr) {
 		while (*ptr != REFRESH_EOL) {
 			CELL cell = origin + *ptr++;
 			if (Map.In_Radar(cell) && techno->Can_Enter_Cell(cell) == MOVE_OK) {
 				return(cell);
 			}
 		}
 	}
 	return(0);
 }
 
 /***********************************************************************************************
  * BuildingClass::Can_Player_Move -- Can this building be moved?                               *
  *                                                                                             *
  *    This routine answers the question 'can this building be moved?' Typically, only the      *
  *    construction yard can be moved and it does this by undeploying back into a MCV.          *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Can the building move to a new location under player control?                      *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/04/1995 JLB : Created.                                                                 *
  *=============================================================================================*/
 bool BuildingClass::Can_Player_Move(void) const
 {
 	Validate();
 	return(*this == STRUCT_CONST && (Mission == MISSION_GUARD) && Special.IsMCVDeploy);
 }
 
 /***********************************************************************************************
  * BuildingClass::Passes_Proximity_Check -- Determines if building placement is near friendly sq*
  *                                                                                             *
  *    This routine is used by the building placement cursor logic to determine whether the     *
  *    at the current cursor position if the building would be adjacent to another friendly     *
  *    building. In cases where this is not true, then the building cannot be placed at all.    *
  *    This determination is returned by the function.                                          *
  *                                                                                             *
  * INPUT:   homecell -- The cell that the building would like to be placed down at.            *
  *                                                                                             *
  * OUTPUT:  bool; Can the pending building object be placed at the present cursor location     *
  *                checking only for proximity to friendly buildings?  If this isn't for a      *
  *                building type object, then this routine always returns true.                 *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/06/1994 JLB : Created.                                                                 *
  *   06/07/1994 JLB : Handles concrete check.                                                  *
  *=============================================================================================*/
 bool BuildingClass::Passes_Proximity_Check(CELL homecell)
 {
 	/*
 	** In editor mode, the proximity check always passes.
 	*/
 	if (Debug_Map || !House->IsHuman) {
 		return(true);
 	}
 
 	/*
 	**	Scan through all cells that the building foundation would cover. If any adjacent
 	**	cells to these are of friendly persuasion, then consider the proximity check to
 	**	have been a success.
 	*/
 	short const * ptr = Occupy_List(true);
 	while (*ptr != REFRESH_EOL) {
 		CELL cell = homecell + *ptr++;
 
 		if (!Map.In_Radar(cell)) return(false);
 
 		for (FacingType facing = FACING_N; facing < FACING_COUNT; facing++) {
 			CELL	newcell = Adjacent_Cell(cell, facing);
 
 			BuildingClass * base = Map[newcell].Cell_Building();
 
 			/*
 			**	The special cell ownership flag allows building adjacent
 			**	to friendly walls and bibs even though there is no official
 			**	building located there.
 			*/
 			if (Map[newcell].Owner == House->Class->House) {
 				return(true);
 			}
 
 			if (base && base->House->Class->House == House->Class->House) {
 				return(true);
 			}
 		}
 	}
 	return(false);
 }