mirror of
https://github.com/electronicarts/CnC_Remastered_Collection
synced 2024-04-29 09:52:36 +12:00
697 lines
26 KiB
C++
697 lines
26 KiB
C++
//
|
|
// 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\reinf.cpv 2.17 16 Oct 1995 16:48:58 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 : REINF.CPP *
|
|
* *
|
|
* Programmer : Joe L. Bostic *
|
|
* *
|
|
* Start Date : May 24, 1994 *
|
|
* *
|
|
* Last Update : July 4, 1995 [JLB] *
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* Create_Air_Reinforcement -- Creates air strike reinforcement *
|
|
* Create_Special_Reinforcement -- Ad hoc reinforcement handler. *
|
|
* Do_Reinforcements -- Create and place a reinforcement team. *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#include "function.h"
|
|
|
|
|
|
/***********************************************************************************************
|
|
* Do_Reinforcements -- Create and place a reinforcement team. *
|
|
* *
|
|
* This routine is called when a reinforcement team must be created and placed on the map. *
|
|
* It will create all members of the team and place them at the location determined from *
|
|
* the team composition. The reinforcement team should follow team orders until overriden *
|
|
* by AI or player intervention. *
|
|
* *
|
|
* INPUT: teamtype -- Pointer to the team type to create as a reinforcement. *
|
|
* *
|
|
* OUTPUT: Was the reinforcement successfully created and placed? *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/08/1995 JLB : Created. *
|
|
* 05/18/1995 JLB : Returns success or failure condition. *
|
|
* 06/19/1995 JLB : Announces reinforcements. *
|
|
*=============================================================================================*/
|
|
bool Do_Reinforcements(TeamTypeClass *teamtype)
|
|
{
|
|
/*
|
|
** preform some preliminary checks for validity.
|
|
*/
|
|
if (!teamtype || !teamtype->ClassCount) return(false);
|
|
|
|
/*
|
|
** Create the controlling team. All the objects are grouped
|
|
** under this team control. If there are no missions for this team
|
|
** then don't actually create the team -- it won't serve a purpose.
|
|
*/
|
|
TeamClass * team = NULL;
|
|
if (teamtype->MissionCount) {
|
|
team = new TeamClass(teamtype, HouseClass::As_Pointer(teamtype->House));
|
|
if (!team) return(false);
|
|
team->Force_Active();
|
|
}
|
|
|
|
/*
|
|
** Determine if this team contains its own transport. In such a case, the
|
|
** transport is used as a loaner. This is only true, if there is other
|
|
** objects to be transport. Without such cargo objects, then the transport
|
|
** is presumed to be the reinforcement itself and thus should not be a
|
|
** loaner.
|
|
*/
|
|
bool okvoice = true; // Presume ok to announce reinforcement?
|
|
bool airtransport = false; // Transport can fly in?
|
|
bool watertransport = false; // Transport needs a beach to land at?
|
|
bool onlytransport = true; // Just transport is in reinforcement?
|
|
bool hastransport = false; // Group comes with transport?
|
|
int index;
|
|
for (index=0; index < teamtype->ClassCount; index++) {
|
|
if (teamtype->Class[index]->IsTransporter || teamtype->Class[index]->What_Am_I() == RTTI_AIRCRAFTTYPE) {
|
|
hastransport = true;
|
|
if (teamtype->Class[index]->What_Am_I() == RTTI_AIRCRAFTTYPE) {
|
|
airtransport = true;
|
|
} else {
|
|
watertransport = (((UnitTypeClass const *)teamtype->Class[index])->Type == UNIT_HOVER);
|
|
}
|
|
} else {
|
|
onlytransport = false;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Now determine how the reinforcement should be delivered. This is largely determined
|
|
** by whether there is a transport with the reinforcements.
|
|
*/
|
|
SourceType source = SOURCE_NONE;
|
|
if (airtransport) {
|
|
source = SOURCE_AIR;
|
|
} else {
|
|
|
|
if (watertransport) {
|
|
source = SOURCE_BEACH;
|
|
} else {
|
|
|
|
/*
|
|
** Special case for the gunboat. It always arrives according to the shipping source.
|
|
*/
|
|
if (teamtype->Class[0]->What_Am_I() == RTTI_UNITTYPE && ((UnitTypeClass const *)teamtype->Class[0])->Type == UNIT_GUNBOAT) {
|
|
source = SOURCE_SHIPPING;
|
|
} else {
|
|
source = HouseClass::As_Pointer(teamtype->House)->Edge;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** If we can't determine where the reinforcement should come from, then delete it
|
|
** and return a failure condition.
|
|
*/
|
|
if (source == SOURCE_NONE) {
|
|
if (team) delete team;
|
|
return(false);
|
|
}
|
|
|
|
/*
|
|
** Now that the official source for the reinforcement has been determined, the
|
|
** objects themselves must be created.
|
|
*/
|
|
TechnoClass * transport = NULL;
|
|
TechnoClass * object = NULL;
|
|
for (index = 0; index < teamtype->ClassCount; index++) {
|
|
TechnoTypeClass const * tclass = teamtype->Class[index];
|
|
|
|
for (int sub = 0; sub < teamtype->DesiredNum[index]; sub++) {
|
|
ScenarioInit++;
|
|
FootClass * temp = (FootClass *)tclass->Create_One_Of(HouseClass::As_Pointer(teamtype->House));
|
|
ScenarioInit--;
|
|
|
|
if (temp) {
|
|
|
|
/*
|
|
** Add the object to the team. This is true even for the transports. The one
|
|
** exception is for the hover lander which never becomes part of the team.
|
|
*/
|
|
if (team && (temp->What_Am_I() != RTTI_UNIT || *((UnitClass*)temp) != UNIT_HOVER)) {
|
|
ScenarioInit++;
|
|
team->Add(temp);
|
|
ScenarioInit--;
|
|
}
|
|
|
|
/*
|
|
** Build the list of transporters and passengers.
|
|
*/
|
|
if (tclass->IsTransporter && (!airtransport || tclass->What_Am_I() == RTTI_AIRCRAFTTYPE)) {
|
|
|
|
/*
|
|
** Transports are considered loaners if they are transporting
|
|
** something. They are presumed to only serve as a delivery
|
|
** agent.
|
|
*/
|
|
if (!onlytransport && temp->What_Am_I() != RTTI_UNIT) {
|
|
temp->IsALoaner = true;
|
|
}
|
|
|
|
/*
|
|
** Link to the list of transports.
|
|
*/
|
|
temp->Next = transport;
|
|
transport = temp;
|
|
} else {
|
|
|
|
/*
|
|
** A-10s are always considered loaners since the player should
|
|
** never be allowed to control them.
|
|
*/
|
|
if (temp->What_Am_I() == RTTI_AIRCRAFT && *((AircraftClass *)temp) == AIRCRAFT_A10) {
|
|
temp->IsALoaner = true;
|
|
}
|
|
|
|
/*
|
|
** Link to the list of normal objects.
|
|
*/
|
|
temp->Next = object;
|
|
object = temp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Bail on this reinforcement if no reinforcements could be created.
|
|
** This is probably because the object maximum was reached.
|
|
*/
|
|
if (!object && !transport) {
|
|
if (team) delete team;
|
|
return(false);
|
|
}
|
|
|
|
/*
|
|
** Now it is time to place the objects on the map. If there is a transport, then the
|
|
** transported objects must be placed inside the transport at this time as well.
|
|
*/
|
|
if (transport) {
|
|
if (object) {
|
|
|
|
/*
|
|
** For cargo planes that carry reinforcements, don't announce arrival
|
|
** when the transport is created. The announcement will occur when the
|
|
** transport unloads.
|
|
*/
|
|
if (transport->What_Am_I() == RTTI_AIRCRAFT && *((AircraftClass *)transport) == AIRCRAFT_CARGO) {
|
|
okvoice = false;
|
|
}
|
|
|
|
transport->Attach((FootClass *)object);
|
|
}
|
|
object = transport;
|
|
}
|
|
|
|
/*
|
|
** Pick the location where the reinforcements appear and then place
|
|
** them there.
|
|
*/
|
|
bool placed = false;
|
|
CELL cell = 0;
|
|
FacingType eface;
|
|
switch (source) {
|
|
|
|
case SOURCE_SHIPPING:
|
|
cell = Map.Calculated_Cell(source, teamtype->House);
|
|
object->IsALoaner = true;
|
|
if (object->Unlimbo(Cell_Coord(cell), DIR_W)) {
|
|
object->Assign_Mission(MISSION_GUARD);
|
|
object->Assign_Destination(::As_Target(XY_Cell(Map.MapCellX-1, Cell_Y(Coord_Cell(object->Coord)) )));
|
|
} else {
|
|
if (team) delete team;
|
|
delete object;
|
|
return(false);
|
|
}
|
|
break;
|
|
|
|
case SOURCE_NORTH:
|
|
case SOURCE_SOUTH:
|
|
case SOURCE_EAST:
|
|
case SOURCE_WEST: {
|
|
eface = (FacingType)(source << 1); // Facing to enter map.
|
|
|
|
if (airtransport) ScenarioInit++;
|
|
cell = Map.Calculated_Cell(source, teamtype->House);
|
|
if (airtransport) ScenarioInit--;
|
|
CELL newcell = cell;
|
|
|
|
FootClass * o = (FootClass *)object->Next;
|
|
object->Next = 0;
|
|
bool ok = true;
|
|
while (newcell > 0 && object) {
|
|
DirType desiredfacing = Facing_Dir(eface);
|
|
if (object->What_Am_I() == RTTI_AIRCRAFT) {
|
|
desiredfacing = Random_Pick(DIR_N, DIR_MAX);
|
|
}
|
|
|
|
if (ok && object->Unlimbo(Cell_Coord(newcell), desiredfacing)) {
|
|
|
|
/*
|
|
** If this object is part of a team, then the mission for this
|
|
** object will be guard. The team handler will assign the proper
|
|
** mission that it should follow.
|
|
*/
|
|
if (object->What_Am_I() == RTTI_AIRCRAFT) {
|
|
ok = false;
|
|
} else {
|
|
if (team) {
|
|
object->Assign_Mission(MISSION_GUARD);
|
|
} else {
|
|
object->Assign_Mission(MISSION_MOVE);
|
|
object->Assign_Destination(Adjacent_Cell(newcell, eface));
|
|
}
|
|
object->Commence();
|
|
}
|
|
|
|
} else {
|
|
ok = true;
|
|
|
|
/*
|
|
** Could not unlimbo at location specified so find an adjacent location that it can
|
|
** be unlimboed at. If this fails, then abort the whole placement process.
|
|
*/
|
|
FacingType adj;
|
|
for (adj = FACING_N; adj < FACING_COUNT; adj++) {
|
|
CELL trycell = Adjacent_Cell(newcell, adj);
|
|
if (!Map.In_Radar(trycell) && object->Can_Enter_Cell(trycell, adj) == MOVE_OK) {
|
|
newcell = trycell;
|
|
break;
|
|
}
|
|
}
|
|
if (adj < FACING_COUNT) continue;
|
|
newcell = -1;
|
|
}
|
|
|
|
object = o;
|
|
if (object) {
|
|
o = (FootClass *)object->Next;
|
|
object->Next = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** If there are still objects that could not be placed, then delete them.
|
|
*/
|
|
if (o) {
|
|
while (o) {
|
|
FootClass * old = o;
|
|
o = (FootClass *)o->Next;
|
|
old->Next = 0;
|
|
|
|
delete old;
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
|
|
/*
|
|
** Bring out the aircraft as separate "groups" of one.
|
|
*/
|
|
case SOURCE_AIR: {
|
|
AircraftClass * thisone = (AircraftClass *)object;
|
|
TARGET target = TARGET_NONE;
|
|
while (thisone) {
|
|
AircraftClass * next = (AircraftClass *)thisone->Next;
|
|
|
|
/*
|
|
** Find a suitable map entry location. Cargo planes will try to find a cell that
|
|
** exactly lines up with the airfield they will unload at.
|
|
*/
|
|
COORDINATE newcoord;
|
|
long reinforcement_delay = -1;
|
|
ScenarioInit++;
|
|
newcoord = Cell_Coord(Map.Calculated_Cell(HouseClass::As_Pointer(teamtype->House)->Edge, teamtype->House));
|
|
ScenarioInit--;
|
|
if (*thisone == AIRCRAFT_CARGO) {
|
|
BuildingClass const * building = thisone->Find_Docking_Bay(STRUCT_AIRSTRIP, false);
|
|
if (building) {
|
|
COORDINATE docking_coord = building->Docking_Coord();
|
|
const int border_x = Cell_To_Lepton(Map.MapCellX + Map.MapCellWidth) | 0x80;
|
|
if (Special.ModernBalance) {
|
|
/*
|
|
** Cargo plane takes 5 seconds to reach the airstrip on Normal (1.5x legacy), or (75 / 10) seconds at speed.
|
|
** Assumes a 45ms (1000 / 45 ticks per second) service rate.
|
|
*/
|
|
const int speed = AircraftTypeClass::As_Reference(AIRCRAFT_CARGO).MaxSpeed;
|
|
int spawn_x = Coord_X(docking_coord) + ((speed * 1000 * 75) / (45 * 10));
|
|
if (spawn_x > border_x) {
|
|
reinforcement_delay = (spawn_x - border_x) / speed;
|
|
spawn_x = border_x;
|
|
}
|
|
newcoord = XY_Coord(spawn_x, Coord_Y(docking_coord));
|
|
} else {
|
|
newcoord = XY_Coord(border_x, Coord_Y(docking_coord));
|
|
}
|
|
if (teamtype->MissionCount) {
|
|
teamtype->MissionList[0].Argument = building->As_Target();
|
|
}
|
|
}
|
|
}
|
|
thisone->Next = 0;
|
|
|
|
ScenarioInit++;
|
|
placed = thisone->Unlimbo(newcoord, DIR_W);
|
|
if (Special.ModernBalance && reinforcement_delay >= 0) {
|
|
thisone->Set_Reinforcement_Delay(reinforcement_delay);
|
|
}
|
|
ScenarioInit--;
|
|
if (placed) {
|
|
if (!team) {
|
|
if (thisone->Class->IsFixedWing) {
|
|
thisone->Assign_Mission(MISSION_HUNT);
|
|
if (*thisone == AIRCRAFT_A10) {
|
|
/*
|
|
** Groups of A10s always go after the same target initally.
|
|
*/
|
|
if (target == TARGET_NONE) {
|
|
target = thisone->Greatest_Threat(THREAT_NORMAL);
|
|
}
|
|
thisone->Assign_Target(target);
|
|
}
|
|
} else {
|
|
if (thisone->Class->IsTransporter && thisone->Is_Something_Attached()) {
|
|
thisone->Assign_Mission(MISSION_UNLOAD);
|
|
} else {
|
|
thisone->Assign_Mission(MISSION_MOVE);
|
|
}
|
|
thisone->Assign_Destination(::As_Target(Map.Calculated_Cell(source, teamtype->House)));
|
|
}
|
|
thisone->Commence();
|
|
}
|
|
} else {
|
|
delete thisone;
|
|
}
|
|
|
|
thisone = next;
|
|
}
|
|
if (!placed && team) delete team;
|
|
|
|
|
|
/*
|
|
** Fixes bug that can happen if the reinforcement cannot be created.
|
|
** This prevent "phantom" teams and team types from being left around.
|
|
*/
|
|
if (GameToPlay == GAME_NORMAL && !placed) return(false);
|
|
|
|
}
|
|
break;
|
|
|
|
case SOURCE_OCEAN:
|
|
case SOURCE_BEACH:
|
|
cell = Map.Calculated_Cell(SOURCE_BEACH, teamtype->House);
|
|
if (cell) {
|
|
CELL edge = XY_Cell(Cell_X(cell), Map.MapCellY+Map.MapCellHeight);
|
|
|
|
placed = object->Unlimbo(Cell_Coord(edge), DIR_N);
|
|
if (placed) {
|
|
if (!team) {
|
|
object->IsLocked = false;
|
|
object->Assign_Mission(MISSION_UNLOAD);
|
|
object->Commence();
|
|
object->Assign_Destination(::As_Target(cell));
|
|
}
|
|
} else {
|
|
if (team) delete team;
|
|
delete object;
|
|
return(false);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/*
|
|
** Announce when the reinforcements have arrived.
|
|
*/
|
|
if (okvoice && teamtype->House == PlayerPtr->Class->House) {
|
|
Speak(VOX_REINFORCEMENTS, NULL, cell ? Cell_Coord(cell) : 0);
|
|
}
|
|
|
|
return(true);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* Create_Special_Reinforcement -- Ad hoc reinforcement handler. *
|
|
* *
|
|
* Use this routine to bring on a reinforcement that hasn't been anticipated by the trigger *
|
|
* system. An example of this would be replacement harvesters or airfield ordered units. *
|
|
* The appropriate transport is created (if necessary) and a mission is assigned such that *
|
|
* the object will legally bring itself onto the playing field. *
|
|
* *
|
|
* INPUT: house -- The owner of this reinforcement. *
|
|
* *
|
|
* type -- The object to bring on. *
|
|
* *
|
|
* another -- This is reserved for the transport class in those cases where the *
|
|
* transport MUST be forced to a specific type. *
|
|
* *
|
|
* mission -- The mission to assign this reinforcement team. *
|
|
* *
|
|
* argument -- Optional team mission argument (usually a waypoint). *
|
|
* *
|
|
* OUTPUT: Was the special reinforcement created without error? *
|
|
* *
|
|
* WARNINGS: This routine will fail if a team type cannot be created. *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/04/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
bool Create_Special_Reinforcement(HouseClass * house, TechnoTypeClass const * type, TechnoTypeClass const * another, TeamMissionType mission, int argument)
|
|
{
|
|
if (house && type) {
|
|
TeamTypeClass * team = new TeamTypeClass();
|
|
|
|
if (team) {
|
|
|
|
/*
|
|
** If a ground based reinforcement is desired, but the edge of the map that the
|
|
** reinforcement will arrive at is completely covered with water, then add
|
|
** a hover lander for transport.
|
|
*/
|
|
if (!another && (type->What_Am_I() == RTTI_UNITTYPE || type->What_Am_I() == RTTI_INFANTRYTYPE)) {
|
|
|
|
/*
|
|
** Hover lander reinforcements can only arrive from the south. Yes, this is an
|
|
** arbitrary limitation, but that's the way it is (for now).
|
|
*/
|
|
if (house->Edge == SOURCE_SOUTH) {
|
|
bool found = false;
|
|
for (int index = Map.MapCellX; index < Map.MapCellX+Map.MapCellWidth-1; index++) {
|
|
CELL cell = XY_Cell(index, Map.MapCellY+Map.MapCellHeight);
|
|
if (Map[cell].Is_Generally_Clear() && Map[cell-MAP_CELL_W].Is_Generally_Clear()) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** No land route was found for the reinforcement to drive itself onto the
|
|
** map. Assign it a hover lander. This presumes that if the south edge is
|
|
** non drivable, it will have water there instead. Risky, but is not a
|
|
** problem with the current C&C maps.
|
|
*/
|
|
if (!found) {
|
|
mission = TMISSION_NONE;
|
|
another = &UnitTypeClass::As_Reference(UNIT_HOVER);
|
|
}
|
|
}
|
|
|
|
if (!another) {
|
|
mission = TMISSION_MOVECELL;
|
|
argument = Map.Calculated_Cell(SOURCE_AIR, house->Class->House);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** If there is no overridden mission assign to this special reinforcement, then
|
|
** we must assign something. If not, the reinforcement will just sit at the edge
|
|
** of the map.
|
|
*/
|
|
if (!another && mission == TMISSION_NONE) {
|
|
mission = TMISSION_MOVECELL;
|
|
argument = Map.Calculated_Cell(SOURCE_AIR, house->Class->House);
|
|
}
|
|
|
|
/*
|
|
** Fill in the team characteristics.
|
|
*/
|
|
strcpy((char *)&team->IniName[0], "TEMP");
|
|
team->IsReinforcable = false;
|
|
team->IsTransient = true;
|
|
team->ClassCount = 1;
|
|
team->Class[0] = type;
|
|
team->DesiredNum[0] = 1;
|
|
team->MissionCount = 1;
|
|
if (mission == TMISSION_NONE) {
|
|
if (another && (another->What_Am_I() != RTTI_UNITTYPE || ((UnitTypeClass const *)another)->Type != UNIT_HOVER)) {
|
|
team->MissionList[0].Mission = TMISSION_UNLOAD;
|
|
team->MissionList[0].Argument = WAYPT_REINF;
|
|
}
|
|
} else {
|
|
team->MissionList[0].Mission = mission;
|
|
team->MissionList[0].Argument = argument;
|
|
}
|
|
team->House = house->Class->House;
|
|
if (another) {
|
|
team->ClassCount++;
|
|
team->Class[1] = another;
|
|
team->DesiredNum[1] = 1;
|
|
}
|
|
|
|
bool ok = Do_Reinforcements(team);
|
|
if (!ok && GameToPlay == GAME_NORMAL) {
|
|
delete team;
|
|
}
|
|
return(ok);
|
|
}
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* Create_Air_Reinforcement -- Creates air strike reinforcement *
|
|
* *
|
|
* This routine is used to launch an airstrike. It will create the necessary aircraft and *
|
|
* assign them to attack the target specified. This routine bypasses the normal *
|
|
* reinforcement logic since it doesn't need the sophistication of unloading and following *
|
|
* team mission lists. *
|
|
* *
|
|
* INPUT: house -- The purpetrator of this air strike. *
|
|
* *
|
|
* air -- The type of aircraft to make up this airstrike. *
|
|
* *
|
|
* number -- The number of aircraft in this airstrike. *
|
|
* *
|
|
* mission -- The mission to assign the aircraft. *
|
|
* *
|
|
* tarcom -- The target to assign these aircraft. *
|
|
* *
|
|
* navcom -- The navigation target to assign (if necessary). *
|
|
* *
|
|
* OUTPUT: Returns the number of aircraft created for this airstrike. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/04/1995 JLB : Commented. *
|
|
*=============================================================================================*/
|
|
int Create_Air_Reinforcement(HouseClass *house, AircraftType air, int number, MissionType mission, TARGET tarcom, TARGET navcom)
|
|
{
|
|
/*
|
|
** Get a pointer to the class of the object that we are going to create.
|
|
*/
|
|
TechnoTypeClass const * type = (TechnoTypeClass *)&AircraftTypeClass::As_Reference(air);
|
|
|
|
/*
|
|
** Loop through the number of objects we are supposed to create and
|
|
** create and place them on the map.
|
|
*/
|
|
int sub;
|
|
for (sub = 0; sub < number; sub++) {
|
|
|
|
/*
|
|
** Create one of the required objects. If this fails we could have
|
|
** a real problem.
|
|
*/
|
|
ScenarioInit++;
|
|
TechnoClass * obj = (TechnoClass *)type->Create_One_Of(house);
|
|
ScenarioInit--;
|
|
if (!obj) return(sub);
|
|
|
|
/*
|
|
** Flying objects always have the IsALoaner bit set.
|
|
*/
|
|
obj->IsALoaner = true;
|
|
|
|
/*
|
|
** Find a cell for the object to come in on. This is stolen from the
|
|
** the code that handles a SOURCE_AIR in the normal logic.
|
|
*/
|
|
SourceType source = house->Edge;
|
|
switch (source) {
|
|
case SOURCE_NORTH:
|
|
case SOURCE_EAST:
|
|
case SOURCE_SOUTH:
|
|
case SOURCE_WEST:
|
|
break;
|
|
|
|
default:
|
|
source = SOURCE_NORTH;
|
|
break;
|
|
}
|
|
CELL newcell = Map.Calculated_Cell(source, house->Class->House);
|
|
|
|
/*
|
|
** Try and place the object onto the map.
|
|
*/
|
|
ScenarioInit++;
|
|
int placed = obj->Unlimbo(Cell_Coord(newcell), DIR_N);
|
|
ScenarioInit--;
|
|
if (placed) {
|
|
|
|
/*
|
|
** If we suceeded in placing the obj onto the map then
|
|
** now we need to give it a mission and destination.
|
|
*/
|
|
obj->Assign_Mission(mission);
|
|
|
|
/*
|
|
** If a navcom was specified then set it.
|
|
*/
|
|
if (navcom != TARGET_NONE) {
|
|
obj->Assign_Destination(navcom);
|
|
}
|
|
|
|
/*
|
|
** If a tarcom was specified then set it.
|
|
*/
|
|
if (tarcom != TARGET_NONE) {
|
|
obj->Assign_Target(tarcom);
|
|
}
|
|
|
|
/*
|
|
** Start the object into action.
|
|
*/
|
|
obj->Commence();
|
|
} else {
|
|
delete obj;
|
|
sub--;
|
|
return(sub);
|
|
}
|
|
}
|
|
return(sub);
|
|
}
|