mirror of
https://github.com/electronicarts/CnC_Renegade.git
synced 2025-12-15 23:21:40 -05:00
Initial commit of Command & Conquer Renegade source code.
This commit is contained in:
LFeenanEA
811
Code/Combat/vehiclefactorygameobj.cpp
Normal file
811
Code/Combat/vehiclefactorygameobj.cpp
Normal file
@@ -0,0 +1,811 @@
|
||||
/*
|
||||
** Command & Conquer Renegade(tm)
|
||||
** Copyright 2025 Electronic Arts Inc.
|
||||
**
|
||||
** This program is free software: you can redistribute it and/or modify
|
||||
** it under the terms of the GNU General Public License as published by
|
||||
** the Free Software Foundation, either version 3 of the License, or
|
||||
** (at your option) any later version.
|
||||
**
|
||||
** This program is distributed in the hope that it will be useful,
|
||||
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
** GNU General Public License for more details.
|
||||
**
|
||||
** You should have received a copy of the GNU General Public License
|
||||
** along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/***********************************************************************************************
|
||||
*** Confidential - Westwood Studios ***
|
||||
***********************************************************************************************
|
||||
* *
|
||||
* Project Name : Commando *
|
||||
* *
|
||||
* $Archive:: /Commando/Code/Combat/vehiclefactorygameobj.cpp $*
|
||||
* *
|
||||
* $Author:: Byon_g $*
|
||||
* *
|
||||
* $Modtime:: 3/19/02 10:44a $*
|
||||
* *
|
||||
* $Revision:: 26 $*
|
||||
* *
|
||||
*---------------------------------------------------------------------------------------------*
|
||||
* Functions: *
|
||||
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
||||
|
||||
#include "vehiclefactorygameobj.h"
|
||||
#include "basecontroller.h"
|
||||
#include "vehicle.h"
|
||||
#include "wwhack.h"
|
||||
#include "simpledefinitionfactory.h"
|
||||
#include "persistfactory.h"
|
||||
#include "definitionmgr.h"
|
||||
#include "combatchunkid.h"
|
||||
#include "debug.h"
|
||||
#include "scriptzone.h"
|
||||
#include "wwprofile.h"
|
||||
#include "basecontroller.h"
|
||||
#include "doors.h"
|
||||
#include "objlibrary.h"
|
||||
#include "combat.h"
|
||||
#include "soldier.h"
|
||||
#include "pathfind.h"
|
||||
#include "waypath.h"
|
||||
#include "gameobjmanager.h"
|
||||
#include "mapmgr.h"
|
||||
|
||||
|
||||
const float UNITIALIZED_TIMER = -100.0F;
|
||||
const int DEFAULT_MAX_VEHICLES_PER_TEAM = 8;
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Hacks
|
||||
////////////////////////////////////////////////////////////////
|
||||
DECLARE_FORCE_LINK (VehicleFactory)
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Editable and persist factories
|
||||
////////////////////////////////////////////////////////////////
|
||||
SimplePersistFactoryClass <VehicleFactoryGameObjDef, CHUNKID_GAME_OBJECT_DEF_VEHICLE_FACTORY> _VehicleFactoryGameObjDefPersistFactory;
|
||||
SimplePersistFactoryClass <VehicleFactoryGameObj, CHUNKID_GAME_OBJECT_VEHICLE_FACTORY> _VehicleFactoryGameObjPersistFactory;
|
||||
DECLARE_DEFINITION_FACTORY (VehicleFactoryGameObjDef, CLASSID_GAME_OBJECT_DEF_VEHICLE_FACTORY, "Vehicle Factory") _VehicleFactoryGameObjDefDefFactory (false);
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Static members
|
||||
////////////////////////////////////////////////////////////////
|
||||
int VehicleFactoryGameObj::MaxVehiclesPerTeam = DEFAULT_MAX_VEHICLES_PER_TEAM;
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Save/Load constants
|
||||
////////////////////////////////////////////////////////////////
|
||||
enum
|
||||
{
|
||||
CHUNKID_DEF_PARENT = 0x02200638,
|
||||
CHUNKID_DEF_VARIABLES,
|
||||
|
||||
MICROCHUNKID_DEF_UNUSED = 1,
|
||||
MICROCHUNKID_DEF_PADCLEARINGWARHEAD,
|
||||
MICROCHUNKID_DEF_TOTALBUILDINGTIME,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
CHUNKID_PARENT = 0x0219043,
|
||||
CHUNKID_VARIABLES,
|
||||
|
||||
MICROCHUNKID_CREATION_TM = 1,
|
||||
MICROCHUNKID_IS_BUSY,
|
||||
MICROCHUNKID_GENERATION_TIME,
|
||||
MICROCHUNKID_GENERATING_VEHICLE_ID,
|
||||
};
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// VehicleFactoryGameObjDef
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
VehicleFactoryGameObjDef::VehicleFactoryGameObjDef (void) :
|
||||
PadClearingWarhead(25), // default to "DEATH"
|
||||
TotalBuildingTime(12.0f)
|
||||
{
|
||||
#ifdef PARAM_EDITING_ON
|
||||
EnumParameterClass *param = new EnumParameterClass( &PadClearingWarhead );
|
||||
param->Set_Name ( "Pad Clearing Warhead" );
|
||||
for (int i = 0; i < ArmorWarheadManager::Get_Num_Warhead_Types(); i++) {
|
||||
param->Add_Value ( ArmorWarheadManager::Get_Warhead_Name( i ), i );
|
||||
}
|
||||
GENERIC_EDITABLE_PARAM(VehicleFactoryGameObjDef,param)
|
||||
#endif
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// ~VehicleFactoryGameObjDef
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
VehicleFactoryGameObjDef::~VehicleFactoryGameObjDef (void)
|
||||
{
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Get_Class_ID
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
uint32
|
||||
VehicleFactoryGameObjDef::Get_Class_ID (void) const
|
||||
{
|
||||
return CLASSID_GAME_OBJECT_DEF_VEHICLE_FACTORY;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Create
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
PersistClass *
|
||||
VehicleFactoryGameObjDef::Create (void) const
|
||||
{
|
||||
VehicleFactoryGameObj *building = new VehicleFactoryGameObj;
|
||||
building->Init (*this);
|
||||
|
||||
return building;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Create
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
bool
|
||||
VehicleFactoryGameObjDef::Save (ChunkSaveClass &csave)
|
||||
{
|
||||
csave.Begin_Chunk (CHUNKID_DEF_PARENT);
|
||||
BuildingGameObjDef::Save (csave);
|
||||
csave.End_Chunk ();
|
||||
|
||||
csave.Begin_Chunk (CHUNKID_DEF_VARIABLES);
|
||||
WRITE_MICRO_CHUNK (csave, MICROCHUNKID_DEF_PADCLEARINGWARHEAD, PadClearingWarhead);
|
||||
WRITE_MICRO_CHUNK (csave, MICROCHUNKID_DEF_TOTALBUILDINGTIME, TotalBuildingTime);
|
||||
csave.End_Chunk ();
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Load
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
bool
|
||||
VehicleFactoryGameObjDef::Load (ChunkLoadClass &cload)
|
||||
{
|
||||
while (cload.Open_Chunk ())
|
||||
{
|
||||
switch (cload.Cur_Chunk_ID ())
|
||||
{
|
||||
case CHUNKID_DEF_PARENT:
|
||||
BuildingGameObjDef::Load (cload);
|
||||
break;
|
||||
|
||||
case CHUNKID_DEF_VARIABLES:
|
||||
Load_Variables (cload);
|
||||
break;
|
||||
|
||||
default:
|
||||
Debug_Say (("Unrecognized Vehicle Factory Def chunkID\n"));
|
||||
break;
|
||||
|
||||
}
|
||||
cload.Close_Chunk ();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Load_Variables
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void
|
||||
VehicleFactoryGameObjDef::Load_Variables (ChunkLoadClass &cload)
|
||||
{
|
||||
while (cload.Open_Micro_Chunk ()) {
|
||||
|
||||
switch (cload.Cur_Micro_Chunk_ID ())
|
||||
{
|
||||
READ_MICRO_CHUNK (cload, MICROCHUNKID_DEF_PADCLEARINGWARHEAD, PadClearingWarhead);
|
||||
READ_MICRO_CHUNK (cload, MICROCHUNKID_DEF_TOTALBUILDINGTIME, TotalBuildingTime);
|
||||
default:
|
||||
Debug_Say (("Unrecognized Vehicle Factory Def Variable chunkID\n"));
|
||||
break;
|
||||
}
|
||||
|
||||
cload.Close_Micro_Chunk();
|
||||
}
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Get_Factory
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
const PersistFactoryClass &
|
||||
VehicleFactoryGameObjDef::Get_Factory (void) const
|
||||
{
|
||||
return _VehicleFactoryGameObjDefPersistFactory;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// VehicleFactoryGameObj
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
VehicleFactoryGameObj::VehicleFactoryGameObj (void) :
|
||||
CreationTM (1),
|
||||
IsBusy (false),
|
||||
GenerationTime (0),
|
||||
GeneratingVehicleID (0),
|
||||
GeneratingRegion (Vector3 (0, 0, 0), Vector3 (0, 0, 0)),
|
||||
LastDeliveryPath (0),
|
||||
EndTimer (UNITIALIZED_TIMER)
|
||||
{
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// ~VehicleFactoryGameObj
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
VehicleFactoryGameObj::~VehicleFactoryGameObj (void)
|
||||
{
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Get_Factory
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
const PersistFactoryClass &
|
||||
VehicleFactoryGameObj::Get_Factory (void) const
|
||||
{
|
||||
return _VehicleFactoryGameObjPersistFactory;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Init
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void VehicleFactoryGameObj::Init (void)
|
||||
{
|
||||
Init (Get_Definition ());
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Init
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void
|
||||
VehicleFactoryGameObj::Init (const VehicleFactoryGameObjDef &definition)
|
||||
{
|
||||
BuildingGameObj::Init (definition);
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Get_Definition
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
const VehicleFactoryGameObjDef &
|
||||
VehicleFactoryGameObj::Get_Definition (void) const
|
||||
{
|
||||
return (const VehicleFactoryGameObjDef &)BaseGameObj::Get_Definition ();
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Save
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
bool
|
||||
VehicleFactoryGameObj::Save (ChunkSaveClass &csave)
|
||||
{
|
||||
csave.Begin_Chunk (CHUNKID_PARENT);
|
||||
BuildingGameObj::Save (csave);
|
||||
csave.End_Chunk ();
|
||||
|
||||
csave.Begin_Chunk (CHUNKID_VARIABLES);
|
||||
|
||||
WRITE_MICRO_CHUNK (csave, MICROCHUNKID_CREATION_TM, CreationTM);
|
||||
WRITE_MICRO_CHUNK (csave, MICROCHUNKID_IS_BUSY, IsBusy);
|
||||
WRITE_MICRO_CHUNK (csave, MICROCHUNKID_GENERATION_TIME, GenerationTime);
|
||||
WRITE_MICRO_CHUNK (csave, MICROCHUNKID_GENERATING_VEHICLE_ID, GeneratingVehicleID);
|
||||
|
||||
csave.End_Chunk ();
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Load
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
bool
|
||||
VehicleFactoryGameObj::Load (ChunkLoadClass &cload)
|
||||
{
|
||||
while (cload.Open_Chunk ()) {
|
||||
switch (cload.Cur_Chunk_ID ()) {
|
||||
|
||||
case CHUNKID_PARENT:
|
||||
BuildingGameObj::Load (cload);
|
||||
break;
|
||||
|
||||
case CHUNKID_VARIABLES:
|
||||
Load_Variables (cload);
|
||||
break;
|
||||
|
||||
default:
|
||||
Debug_Say (("Unrecognized Vehicle Factory chunkID\n"));
|
||||
break;
|
||||
}
|
||||
|
||||
cload.Close_Chunk();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Load_Variables
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void
|
||||
VehicleFactoryGameObj::Load_Variables (ChunkLoadClass &cload)
|
||||
{
|
||||
while (cload.Open_Micro_Chunk ()) {
|
||||
|
||||
switch (cload.Cur_Micro_Chunk_ID ())
|
||||
{
|
||||
READ_MICRO_CHUNK (cload, MICROCHUNKID_CREATION_TM, CreationTM);
|
||||
READ_MICRO_CHUNK (cload, MICROCHUNKID_IS_BUSY, IsBusy);
|
||||
READ_MICRO_CHUNK (cload, MICROCHUNKID_GENERATION_TIME, GenerationTime);
|
||||
READ_MICRO_CHUNK (cload, MICROCHUNKID_GENERATING_VEHICLE_ID, GeneratingVehicleID);
|
||||
|
||||
default:
|
||||
Debug_Say (("Unrecognized Vehicle Factory Variable chunkID\n"));
|
||||
break;
|
||||
}
|
||||
|
||||
cload.Close_Micro_Chunk();
|
||||
}
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// CnC_Initialize
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void
|
||||
VehicleFactoryGameObj::CnC_Initialize (BaseControllerClass *base)
|
||||
{
|
||||
BuildingGameObj::CnC_Initialize (base);
|
||||
|
||||
//
|
||||
// Get the building's "position"
|
||||
//
|
||||
Vector3 pos;
|
||||
Get_Position (&pos);
|
||||
|
||||
//
|
||||
// Find the closest vehicle construction zone to the building
|
||||
//
|
||||
ScriptZoneGameObj *zone = NULL;
|
||||
zone = ScriptZoneGameObj::Find_Closest_Zone (pos, ZoneConstants::TYPE_VEHICLE_CONSTRUCTION);
|
||||
if (zone != NULL) {
|
||||
GeneratingRegion = zone->Get_Bounding_Box ();
|
||||
|
||||
//
|
||||
// Get rid of the zone (if the game doesn't need it anymore)
|
||||
//
|
||||
if (zone->Get_Observers ().Count () == 0) {
|
||||
zone->Set_Delete_Pending ();
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Let the base know it can generate vehicles
|
||||
//
|
||||
if (BaseController != NULL) {
|
||||
BaseController->Set_Can_Generate_Vehicles (true);
|
||||
}
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Think
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void
|
||||
VehicleFactoryGameObj::Think (void)
|
||||
{
|
||||
WWPROFILE ("Vehicle Factory Think");
|
||||
|
||||
if (EndTimer > UNITIALIZED_TIMER) {
|
||||
EndTimer -= TimeManager::Get_Frame_Seconds ();
|
||||
if (EndTimer < 0) {
|
||||
|
||||
//
|
||||
// Handle the end-condition
|
||||
//
|
||||
On_Generation_Complete ();
|
||||
EndTimer = UNITIALIZED_TIMER;
|
||||
}
|
||||
}
|
||||
|
||||
BuildingGameObj::Think ();
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Is_Available_For_Purchase
|
||||
//
|
||||
// In addition to checking whether the factory is busy or
|
||||
// destroyed, this function checks whether the team has
|
||||
// already created its maximum number of vehicles.
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
bool
|
||||
VehicleFactoryGameObj::Is_Available_For_Purchase (void) const
|
||||
{
|
||||
int team_vehicle_count = Get_Team_Vehicle_Count();
|
||||
return (Is_Available() & (team_vehicle_count < Get_Max_Vehicles_Per_Team()));
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Is_Available_For_Purchase
|
||||
//
|
||||
// Counts the number of vehicles active for this factory's team
|
||||
// (not including the harvester!)
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
int
|
||||
VehicleFactoryGameObj::Get_Team_Vehicle_Count(void) const
|
||||
{
|
||||
int team_vehicle_count = 0;
|
||||
|
||||
VehicleGameObj * harvy = NULL;
|
||||
BaseControllerClass * base = BaseControllerClass::Find_Base(Get_Player_Type());
|
||||
if (base != NULL) {
|
||||
harvy = base->Get_Harvester_Vehicle();
|
||||
}
|
||||
|
||||
SLNode<SmartGameObj> * smart_objnode;
|
||||
for (smart_objnode = GameObjManager::Get_Smart_Game_Obj_List()->Head(); smart_objnode; smart_objnode = smart_objnode->Next()) {
|
||||
VehicleGameObj * obj = smart_objnode->Data()->As_VehicleGameObj();
|
||||
|
||||
if ( (obj != NULL) &&
|
||||
(obj != harvy) &&
|
||||
(obj->Peek_Physical_Object() != NULL) &&
|
||||
(obj->Peek_Physical_Object()->As_VehiclePhysClass() != NULL) )
|
||||
{
|
||||
if (obj->Get_Definition().Get_Default_Player_Type() == Get_Player_Type()) {
|
||||
team_vehicle_count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
return team_vehicle_count;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// On_Generation_Complete
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void
|
||||
VehicleFactoryGameObj::On_Generation_Complete (void)
|
||||
{
|
||||
//
|
||||
// Notify the base that we just created a vehicle
|
||||
//
|
||||
if (Vehicle != NULL) {
|
||||
|
||||
//
|
||||
// Shut off the action making the vehicle drive off the pad.
|
||||
// (if it didn't make it by now, give up anyway)
|
||||
//
|
||||
VehicleGameObj * vehicle_obj = Vehicle.Get_Ptr ()->As_VehicleGameObj();
|
||||
if (vehicle_obj != NULL) {
|
||||
ActionClass * action = vehicle_obj->Get_Action();
|
||||
if (action != NULL) {
|
||||
|
||||
// Change the arrived distance so the vehicles think
|
||||
// they've arrived at their destination (complete the action)
|
||||
action->Get_Parameters().Set_Movement(Vector3(0,0,0), 0.0f, 1000.0f);
|
||||
}
|
||||
BaseController->On_Vehicle_Generated (vehicle_obj);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Reset our variables
|
||||
//
|
||||
GeneratingVehicleID = 0;
|
||||
GenerationTime = 0;
|
||||
IsBusy = false;
|
||||
Set_Object_Dirty_Bit (BIT_RARE, true);
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// On_Destroyed
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void
|
||||
VehicleFactoryGameObj::On_Destroyed (void)
|
||||
{
|
||||
BuildingGameObj::On_Destroyed ();
|
||||
|
||||
//
|
||||
// Switch off the ability to build vehicles
|
||||
//
|
||||
if (BaseController != NULL && CombatManager::I_Am_Server ()) {
|
||||
BaseController->Set_Can_Generate_Vehicles (false);
|
||||
}
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Request_Vehicle
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
bool
|
||||
VehicleFactoryGameObj::Request_Vehicle (int definition_id, float generation_time,SoldierGameObj * purchaser)
|
||||
{
|
||||
bool retval = false;
|
||||
|
||||
//
|
||||
// Start the generation if possible
|
||||
//
|
||||
if (IsBusy == false && definition_id != 0) {
|
||||
GeneratingVehicleID = definition_id;
|
||||
GenerationTime = generation_time;
|
||||
IsBusy = true;
|
||||
Purchaser = purchaser;
|
||||
EndTimer = Get_Definition().Get_Total_Building_Time();
|
||||
|
||||
Begin_Generation ();
|
||||
Set_Object_Dirty_Bit (BIT_RARE, true);
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Destroy_Blocking_Objects
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void
|
||||
VehicleFactoryGameObj::Destroy_Blocking_Objects (void)
|
||||
{
|
||||
if (CombatManager::I_Am_Server () == false) {
|
||||
return ;
|
||||
}
|
||||
|
||||
//
|
||||
// Collect the dynamic physics objects in the generation region
|
||||
//
|
||||
NonRefPhysListClass objs_to_kill;
|
||||
PhysicsSceneClass::Get_Instance ()->Collect_Objects (GeneratingRegion, false, true, &objs_to_kill);
|
||||
|
||||
//
|
||||
// Loop over all the objects
|
||||
//
|
||||
NonRefPhysListIterator it (&objs_to_kill);
|
||||
for (it.First (); !it.Is_Done (); it.Next ()) {
|
||||
PhysicalGameObj *gameobj = NULL;
|
||||
|
||||
//
|
||||
// Get the game object from this physics object
|
||||
//
|
||||
if (it.Peek_Obj()->Get_Observer () != NULL) {
|
||||
gameobj = ((CombatPhysObserverClass *)it.Peek_Obj()->Get_Observer())->As_PhysicalGameObj();
|
||||
}
|
||||
|
||||
//
|
||||
// Kill the object
|
||||
//
|
||||
if (gameobj != NULL && gameobj != Vehicle && gameobj->As_ArmedGameObj () != NULL) {
|
||||
|
||||
//
|
||||
// Destroy the object
|
||||
//
|
||||
OffenseObjectClass offense_obj (10000.0F, Get_Definition().Get_Pad_Clearing_Warhead());
|
||||
gameobj->Apply_Damage_Extended( offense_obj );
|
||||
}
|
||||
}
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Deliver_Vehicle,
|
||||
// Gives the vehicle an action to follow one of the delivery
|
||||
// waypaths out of the construction zone.
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
void
|
||||
VehicleFactoryGameObj::Deliver_Vehicle(void)
|
||||
{
|
||||
//
|
||||
// Give the vehicle a command to drive to one of the delivery points
|
||||
//
|
||||
PathfindClass * pathfind = PathfindClass::Get_Instance();
|
||||
AABoxClass box;
|
||||
box.Center = GeneratingRegion.Center;
|
||||
box.Extent = GeneratingRegion.Extent;
|
||||
|
||||
if (pathfind != NULL) {
|
||||
|
||||
WaypathClass * path = pathfind->Get_Waypath_Starting_In_Box(box,LastDeliveryPath);
|
||||
|
||||
if (path != NULL) {
|
||||
|
||||
LastDeliveryPath = (LastDeliveryPath + 1) % pathfind->Count_Waypaths_Starting_In_Box(box);
|
||||
|
||||
if ((Vehicle.Get_Ptr() != NULL) && (Vehicle.Get_Ptr()->As_VehicleGameObj() != NULL)) {
|
||||
VehicleGameObj * vehicle = Vehicle.Get_Ptr ()->As_VehicleGameObj();
|
||||
ActionClass * action = vehicle->Get_Action();
|
||||
if (action != NULL) {
|
||||
|
||||
ActionParamsStruct parameters;
|
||||
parameters.Priority = 1;
|
||||
parameters.Set_Movement(Vector3(0,0,0), 1.0f, 1.0f);
|
||||
parameters.WaypathID = path->Get_ID();
|
||||
parameters.ShutdownEngineOnArrival = true;
|
||||
|
||||
action->Goto(parameters);
|
||||
|
||||
vehicle->Set_Vehicle_Delivered();
|
||||
BaseController->On_Vehicle_Delivered(vehicle);
|
||||
}
|
||||
}
|
||||
|
||||
REF_PTR_RELEASE(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Create_Vehicle
|
||||
//
|
||||
////////////////////////////////////////////////////////////////
|
||||
VehicleGameObj *
|
||||
VehicleFactoryGameObj::Create_Vehicle (void)
|
||||
{
|
||||
if (CombatManager::I_Am_Server () == false) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
VehicleGameObj *vehicle = NULL;
|
||||
|
||||
if (GeneratingVehicleID != 0) {
|
||||
|
||||
//
|
||||
// Create the vehicle object
|
||||
//
|
||||
PhysicalGameObj *physical_obj = ObjectLibraryManager::Create_Object (GeneratingVehicleID);
|
||||
|
||||
//
|
||||
// If this is a VTOL vehicle, see if we should let them have it...
|
||||
//
|
||||
if ((physical_obj != NULL) && (physical_obj->Peek_Physical_Object() != NULL)) {
|
||||
|
||||
if ( (MapMgrClass::Are_VTOL_Vehicles_Enabled() == false) &&
|
||||
(physical_obj->Peek_Physical_Object()->As_VTOLVehicleClass() != NULL)
|
||||
)
|
||||
{
|
||||
physical_obj->Set_Delete_Pending();
|
||||
physical_obj = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// If everything is ok, proceed
|
||||
//
|
||||
if (physical_obj != NULL && physical_obj->As_VehicleGameObj () != NULL) {
|
||||
vehicle = physical_obj->As_VehicleGameObj ();
|
||||
vehicle->Start_Observers();
|
||||
|
||||
Vehicle = vehicle;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return vehicle;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Import_Rare
|
||||
//
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
void
|
||||
VehicleFactoryGameObj::Import_Rare (BitStreamClass &packet)
|
||||
{
|
||||
BuildingGameObj::Import_Rare (packet);
|
||||
|
||||
//
|
||||
// Read the state information from the server
|
||||
//
|
||||
packet.Get (IsBusy);
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Export_Rare
|
||||
//
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
void
|
||||
VehicleFactoryGameObj::Export_Rare (BitStreamClass &packet)
|
||||
{
|
||||
BuildingGameObj::Export_Rare (packet);
|
||||
|
||||
//
|
||||
// Transmit the state information
|
||||
//
|
||||
packet.Add (IsBusy);
|
||||
return ;
|
||||
}
|
||||
Reference in New Issue
Block a user