//
// 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);
}