mirrors
/
CnC_Remastered_Collection
mirror of https://github.com/electronicarts/CnC_Remastered_Collection.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
CnC_Remastered_Collection/REDALERT/TEAM.CPP

3075 lines
125 KiB
C++
Raw Permalink Blame History

//
// 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: /CounterStrike/TEAM.CPP 1 3/03/97 10:25a 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 : TEAM.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : 12/11/94 *
* *
* Last Update : August 27, 1996 [JLB] *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* TeamClass::AI -- Process team logic. *
* TeamClass::Add -- Adds specified object to team. *
* TeamClass::Assign_Mission_Target -- Sets teams mission target and clears old target *
* TeamClass::Calc_Center -- Determines average location of team members. *
* TeamClass::Can_Add -- Determines if the specified object can be added to team. *
* TeamClass::Control -- Updates control on a member unit. *
* TeamClass::Coordinate_Attack -- Handles coordinating a team attack. *
* TeamClass::Coordinate_Conscript -- Gives orders to new recruit. *
* TeamClass::Coordinate_Do -- Handles the team performing specified mission. *
* TeamClass::Coordinate_Move -- Handles team movement coordination. *
* TeamClass::Coordinate_Regroup -- Handles team idling (regrouping). *
* TeamClass::Debug_Dump -- Displays debug information about the team. *
* TeamClass::Detach -- Removes specified target from team tracking. *
* TeamClass::Fetch_A_Leader -- Looks for a suitable leader member of the team. *
* TeamClass::Has_Entered_Map -- Determines if the entire team has entered the map. *
* TeamClass::Init -- Initializes the team objects for scenario preparation. *
* TeamClass::Is_A_Member -- Tests if a unit is a member of a team *
* TeamClass::Is_Leaving_Map -- Checks if team is in process of leaving the map *
* TeamClass::Lagging_Units -- Finds and orders any lagging units to catch up. *
* TeamClass::Recruit -- Attempts to recruit members to the team for the given index ID. *
* TeamClass::Remove -- Removes the specified object from the team. *
* TeamClass::Scan_Limit -- Force all members of the team to have limited scan range. *
* TeamClass::Suspend_Teams -- Suspends activity for low priority teams *
* TeamClass::TMision_Patrol -- Handles patrolling from one location to another. *
* TeamClass::TMission_Attack -- Perform the team attack mission command. *
* TeamClass::TMission_Follow -- Perform the "follow friendlies" team command. *
* TeamClass::TMission_Formation -- Process team formation change command. *
* TeamClass::TMission_Invulnerable -- Makes the entire team invulnerable for a period of tim*
* TeamClass::TMission_Load -- Tells the team to load onto the transport now. *
* TeamClass::TMission_Loop -- Causes the team mission processor to jump to new location. *
* TeamClass::TMission_Set_Global -- Performs a set global flag operation. *
* TeamClass::TMission_Spy -- Perform the team spy mission. *
* TeamClass::TMission_Unload -- Tells the team to unload passengers now. *
* TeamClass::TeamClass -- Constructor for the team object type. *
* TeamClass::Took_Damage -- Informs the team when the team member takes damage. *
* TeamClass::operator delete -- Deallocates a team object. *
* TeamClass::operator new -- Allocates a team object. *
* TeamClass::~TeamClass -- Team object destructor. *
* _Is_It_Breathing -- Checks to see if unit is an active team member. *
* _Is_It_Playing -- Determines if unit is active and an initiated team member. *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
#include "mission.h"
/***********************************************************************************************
* _Is_It_Breathing -- Checks to see if unit is an active team member. *
* *
* A unit could be a team member, but not be active. Such a case would occur when a *
* reinforcement team is inside a transport. It could also occur if a unit is in the *
* process of dying. Call this routine to ensure that the specified unit is a will and *
* able participant in the team. *
* *
* INPUT: object -- Pointer to the unit/infantry/aircraft that is to be checked. *
* *
* OUTPUT: bool; Is the specified unit active and able to be given commands by the team? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/11/1996 JLB : Created. *
*=============================================================================================*/
static inline bool _Is_It_Breathing(FootClass const * object)
{
/*
** If the object is not present or appears to be dead, then it
** certainly isn't an active member of the team.
*/
if (object == NULL || !object->IsActive || object->Strength == 0) return(false);
/*
** If the object is in limbo, then it isn't an active team member either. However, if the
** scenario init flag is on, then it is probably a reinforcement issue or scenario
** creation situation. In such a case, the members are considered active because they need to
** be given special orders and treatment.
*/
if (!ScenarioInit && object->IsInLimbo) return(false);
/*
** Nothing eliminated this object from being considered an active member of the team (i.e.,
** "breathing"), then return that it is ok.
*/
return(true);
}
/***********************************************************************************************
* _Is_It_Playing -- Determines if unit is active and an initiated team member. *
* *
* Use this routine to determine if the specified unit is an active participant of the *
* team. When a unit is first recruited to the team, it must travel to the team's location *
* before it can become an active player. Call this routine to determine if the specified *
* unit can be considered an active player. *
* *
* INPUT: object -- Pointer to the object that is to be checked to see if it is an *
* active player. *
* *
* OUTPUT: bool; Is the specified unit an active, living, initiated member of the team? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/11/1996 JLB : Created. *
*=============================================================================================*/
static inline bool _Is_It_Playing(FootClass const * object)
{
/*
** If the object is not active, then it certainly can be a participating member of the
** team.
*/
if (!_Is_It_Breathing(object)) return(false);
/*
** Only members that have been "Initiated" are considered "playing" participants of the
** team. This results in the team members that are racing to regroup with the team (i.e.,
** not initiated), will continue to catch up to the team even while the initiated team members
** carry out their team specific orders.
*/
if (!object->IsInitiated && object->What_Am_I() != RTTI_AIRCRAFT) return(false);
/*
** If it reaches this point, then nothing appears to disqualify the specified object from
** being considered an active playing member of the team. In this case, return that
** information.
*/
return(true);
}
#ifdef CHEAT_KEYS
/***********************************************************************************************
* TeamClass::Debug_Dump -- Displays debug information about the team. *
* *
* This routine will display information about the team. This is useful for debugging *
* purposes. *
* *
* INPUT: mono -- Pointer to the monochrome screen that the debugging information will *
* be displayed on. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/11/1996 JLB : Created. *
*=============================================================================================*/
void TeamClass::Debug_Dump(MonoClass * mono) const
{
mono->Set_Cursor(1, 20);mono->Printf("%8.8s", Class->IniName);
mono->Set_Cursor(10, 20);mono->Printf("%3d", Total);
mono->Set_Cursor(17, 20);mono->Printf("%3d", Quantity[Class->ID]);
if (CurrentMission != -1) {
mono->Set_Cursor(1, 22);
mono->Printf("%-29s", Class->MissionList[CurrentMission].Description(CurrentMission));
}
mono->Set_Cursor(40, 20);mono->Printf("%-10s", FormationName[Formation]);
mono->Set_Cursor(22, 20);mono->Printf("%08X", Zone);
mono->Set_Cursor(31, 20);mono->Printf("%08X", Target);
mono->Fill_Attrib(53, 20, 12, 1, IsUnderStrength ? MonoClass::INVERSE : MonoClass::NORMAL);
mono->Fill_Attrib(53, 21, 12, 1, IsFullStrength ? MonoClass::INVERSE : MonoClass::NORMAL);
mono->Fill_Attrib(53, 22, 12, 1, IsHasBeen ? MonoClass::INVERSE : MonoClass::NORMAL);
mono->Fill_Attrib(66, 20, 12, 1, IsMoving ? MonoClass::INVERSE : MonoClass::NORMAL);
mono->Fill_Attrib(66, 21, 12, 1, IsForcedActive ? MonoClass::INVERSE : MonoClass::NORMAL);
mono->Fill_Attrib(66, 22, 12, 1, IsReforming ? MonoClass::INVERSE : MonoClass::NORMAL);
}
#endif
/***********************************************************************************************
* TeamClass::Init -- Initializes the team objects for scenario preparation. *
* *
* This routine clears out the team object array in preparation for starting a new *
* scenario. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/29/1994 JLB : Created. *
*=============================================================================================*/
void TeamClass::Init(void)
{
Teams.Free_All();
}
/***********************************************************************************************
* TeamClass::operator new -- Allocates a team object. *
* *
* This routine will allocate a team object from the team object pool. *
* *
* INPUT: size -- The size of the requested allocation. *
* *
* OUTPUT: Returns with a pointer to the freshly allocated team object. If an allocation *
* could not be made, then NULL is returned. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/21/1995 JLB : Created. *
*=============================================================================================*/
void * TeamClass::operator new(size_t)
{
void * ptr = Teams.Allocate();
if (ptr != NULL) {
((TeamClass *)ptr)->Set_Active();
}
return(ptr);
}
/***********************************************************************************************
* TeamClass::operator delete -- Deallocates a team object. *
* *
* This routine will return a team object to the team object pool. *
* *
* INPUT: ptr -- Pointer to the team object to deallocate. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/21/1995 JLB : Created. *
*=============================================================================================*/
void TeamClass::operator delete(void * ptr)
{
if (ptr != NULL) {
((TeamClass *)ptr)->IsActive = false;
}
Teams.Free((TeamClass *)ptr);
}
/***********************************************************************************************
* TeamClass::~TeamClass -- Team object destructor. *
* *
* This routine is called when a team object is destroyed. It handles updating the total *
* number count for this team object type. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/21/1995 JLB : Created. *
* 07/04/1996 JLB : Keeps trigger if trigger still attached to objects. *
*=============================================================================================*/
TeamClass::~TeamClass(void)
{
if (GameActive && Class.Is_Valid()) {
while (Member != NULL) {
Remove(Member);
}
Class->Number--;
/*
** When the team dies, any trigger associated with it, dies as well. This will only occur
** if there are no other objects linked to this trigger. Only player reinforcement
** members that broke off of the team earlier will have this occur.
*/
if (Trigger.Is_Valid()) {
if (Trigger->AttachCount == 0) {
delete (TriggerClass *)Trigger;
}
Trigger = NULL;
}
}
}
/***********************************************************************************************
* TeamClass::TeamClass -- Constructor for the team object type. *
* *
* This routine is called when the team object is created. *
* *
* INPUT: type -- Pointer to the team type to make this team object from. *
* *
* owner -- The owner of this team. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/21/1995 JLB : Created. *
*=============================================================================================*/
TeamClass::TeamClass(TeamTypeClass const * type, HouseClass * owner) :
AbstractClass(RTTI_TEAM, Teams.ID(this)),
Class((TeamTypeClass *)type),
House(owner),
IsForcedActive(false),
IsHasBeen(false),
IsFullStrength(false),
IsUnderStrength(true),
IsReforming(false),
IsLagging(false),
IsAltered(true),
JustAltered(false),
IsMoving(false),
IsNextMission(true),
IsLeaveMap(false),
Suspended(false),
Trigger(NULL),
Zone(TARGET_NONE),
ClosestMember(TARGET_NONE),
MissionTarget(TARGET_NONE),
Target(TARGET_NONE),
Total(0),
Risk(0),
Formation(FORMATION_NONE),
SuspendTimer(0),
CurrentMission(-1),
TimeOut(0),
Member(0)
{
assert(Class);
assert(Class->IsActive);
assert(Class->ClassCount > 0);
if (owner == NULL) {
House = HouseClass::As_Pointer(Class->House);
}
memset(Quantity, 0, sizeof(Quantity));
if (Class->Origin != -1) {
Zone = ::As_Target(Scen.Waypoint[Class->Origin]);
}
Class->Number++;
/*
** If there is a trigger tightly associated with this team, then
** create an instance of that trigger and attach it to the team.
*/
if (Class->Trigger.Is_Valid()) {
Trigger = new TriggerClass(Class->Trigger);
}
}
/***************************************************************************
* TeamClass::Assign_Mission_Target -- Sets mission target and clears old *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 05/16/1995 PWG : Created. *
*=========================================================================*/
void TeamClass::Assign_Mission_Target(TARGET new_target)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
/*
** First go through and find anyone who is currently targeting
** the old mission target and clear their Tarcom.
*/
FootClass * unit = Member;
if (MissionTarget != TARGET_NONE) {
while (unit != NULL) {
bool tar = (unit->TarCom == MissionTarget);
bool nav = (unit->NavCom == MissionTarget);
if (tar || nav) {
/*
** If the unit was doing something related to the team mission
** then we kick him into guard mode so that he is easy to change
** missions for.
*/
unit->Assign_Mission(MISSION_GUARD);
/*
** If the unit's tarcom is set to the old mission target, then
** clear it, so that it will be reset by whatever happens next.
*/
if (nav) {
unit->Assign_Destination(TARGET_NONE);
}
/*
** If the unit's navcom is set to the old mission target, then
** clear it, so that it will be reset by whatever happens next.
*/
if (tar) {
unit->Assign_Target(TARGET_NONE);
}
}
unit = unit->Member;
}
}
/*
** If there is not currently an override on the current mission target
** then assign both MissionTarget and Target to the new target. If
** there is an override, allow the team to keep fighting the override but
** make sure they pick up on the new mission when they are ready.
*/
if (Target == MissionTarget || !Target_Legal(Target)) {
MissionTarget = Target = new_target;
} else {
MissionTarget = new_target;
}
}
/***********************************************************************************************
* TeamClass::AI -- Process team logic. *
* *
* General purpose team logic is handled by this routine. It should be called once per *
* active team per game tick. This routine handles recruitment and assigning orders to *
* member units. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/29/1994 JLB : Created. *
* 01/06/1995 JLB : Choreographed gesture. *
*=============================================================================================*/
void TeamClass::AI(void)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
int desired = 0;
int old_under = IsUnderStrength;
int old_full = IsFullStrength;
/*
** If the team has been suspended then we need to check if it's time for
** us to reactivate the team. If not, no team logic will be processed
** for this team.
*/
if (Suspended) {
if (SuspendTimer != 0) {
return;
}
Suspended = false;
}
/*
** If this team senses that its composition has been altered, then it should
** recalculate the under strength and full strength flags.
*/
if (IsAltered) {
/*
** Figure out the total number of objects that this team type requires.
*/
for (int index = 0; index < Class->ClassCount; index++) {
desired += Class->Members[index].Quantity;
}
assert(desired != 0);
if (Total) {
IsFullStrength = (Total == desired);
if (IsFullStrength) {
IsHasBeen = true;
}
/*
** Reinforceable teams will revert (or snap out of) the under strength
** mode when the members transition the magic 1/3 strength threshold.
*/
if (Class->IsReinforcable) {
if (desired > 2) {
IsUnderStrength = (Total <= desired / 3);
} else {
IsUnderStrength = (Total < desired);
}
} else {
/*
** Teams that are not flagged as reinforceable are never considered under
** strength if the team has already started its main mission. This
** ensures that once the team has started, it won't dally to pick up
** new members.
*/
IsUnderStrength = !IsHasBeen;
}
IsAltered = JustAltered = false;
} else {
IsUnderStrength = true;
IsFullStrength = false;
Zone = TARGET_NONE;
/*
** A team that exists on the player's side is automatically destroyed
** when there are no team members left. This team was created as a
** result of reinforcement logic and no longer needs to exist when there
** are no more team members.
*/
if (IsHasBeen || Session.Type != GAME_NORMAL) {
/*
** If this team had no members (i.e., the team object wasn't terminated by some
** outside means), then pass through the logic triggers to see if one that
** depends on this team leaving the map should be sprung.
*/
if (IsLeaveMap) {
for (int index = 0; index < LogicTriggers.Count(); index++) {
TriggerClass * trig = LogicTriggers[index];
if (trig->Spring(TEVENT_LEAVES_MAP)) {
index--;
if (LogicTriggers.Count() == 0) break;
}
}
}
delete this;
return;
}
}
/*
** If the team has gone from under strength to no longer under
** strength than the team needs to reform.
*/
if (old_under != IsUnderStrength) {
IsReforming = true;
}
}
/*
** If the team is under strength, then flag it to regroup.
*/
if (IsMoving && IsUnderStrength) {
IsMoving = false;
CurrentMission = -1;
if (Total) {
Calc_Center(Zone, ClosestMember);
/*
** When a team is badly damaged and needs to regroup it should
** pick a friendly building to go and regroup at. Its first preference
** should be somewhere near repair factory. If it cannot find a repair
** factory then it should pick another structure that is friendly to
** its side.
*/
CELL dest = As_Cell(Zone);
int max = 0x7FFFFFFF;
for (int index = 0; index < Buildings.Count(); index++) {
BuildingClass * b = Buildings.Ptr(index);
if (b != NULL && !b->IsInLimbo && b->House == House && b->Class->PrimaryWeapon == NULL) {
CELL cell = Coord_Cell(b->Center_Coord());
int dist = ::Distance(b->Center_Coord(), As_Coord(Zone)) * (Map.Cell_Threat(cell, House->Class->House) + 1);
if (*b == STRUCT_REPAIR) {
dist /= 2;
}
if (dist < max) {
cell = Fetch_A_Leader()->Safety_Point(As_Cell(Zone), cell, 2, 4);
// cell = Member->Safety_Point(As_Cell(Zone), cell, 2, 4);
if (cell != -1) {
max = dist;
dest = cell;
}
}
}
}
// Should calculate a regroup location.
Target = ::As_Target(dest);
Coordinate_Move();
return;
} else {
Zone = TARGET_NONE;
}
}
/*
** Flag this team into action when it gets to full strength. Human owned teams are only
** used for reinforcement purposes -- always consider them at full strength.
*/
if (!IsMoving && (IsFullStrength || IsForcedActive)) {
IsMoving = true;
IsHasBeen = true;
IsUnderStrength = false;
/*
** Infantry can do a gesture when they start their mission. Pick
** a gesture at random.
*/
FootClass * techno = Member;
DoType doaction = Percent_Chance(50) ? DO_GESTURE1 : DO_GESTURE2;
while (techno) {
if (_Is_It_Breathing(techno) && techno->What_Am_I() == RTTI_INFANTRY) {
((InfantryClass *)techno)->Do_Action(doaction);
}
if (IsReforming || IsForcedActive) {
techno->IsInitiated = true;
}
techno = techno->Member;
}
CurrentMission = -1;
IsNextMission = true;
// IsForcedActive = false;
}
/*
** If the team is moving or if there is no center position for
** the team, then the center position must be recalculated.
*/
if (IsReforming || IsMoving || Zone == TARGET_NONE || ClosestMember == TARGET_NONE) {
Calc_Center(Zone, ClosestMember);
}
/*
** Try to recruit members if there is room to do so for this team.
** Only try to recruit members for a non player controlled team.
*/
if ((!IsMoving || (!IsFullStrength && Class->IsReinforcable)) && ((!House->IsHuman || !IsHasBeen) && Session.Type == GAME_NORMAL)) {
// if ((!IsMoving || (!IsFullStrength && Class->IsReinforcable)) && ((/*!House->IsHuman ||*/ !IsHasBeen) && Session.Type == GAME_NORMAL)) {
for (int index = 0; index < Class->ClassCount; index++) {
if (Quantity[index] < Class->Members[index].Quantity) {
Recruit(index);
}
}
}
/*
** If there are no members of the team and the team has reached
** full strength at one time, then delete the team.
*/
if (Member == NULL && IsHasBeen) {
/*
** If this team had no members (i.e., the team object wasn't terminated by some
** outside means), then pass through the logic triggers to see if one that
** depends on this team leaving the map should be sprung.
*/
if (IsLeaveMap) {
for (int index = 0; index < LogicTriggers.Count(); index++) {
TriggerClass * trig = LogicTriggers[index];
if (trig->Spring(TEVENT_LEAVES_MAP)) {
index--;
if (LogicTriggers.Count() == 0) break;
}
}
}
delete this;
return;
}
/*
** If the mission should be advanced to the next entry, then do so at
** this time. Various events may cause the mission to advance, but it
** all boils down to the following change-mission code.
*/
if (IsMoving && !IsReforming && IsNextMission) {
IsNextMission = false;
CurrentMission++;
if (CurrentMission < Class->MissionCount) {
TeamMissionClass const * mission = &Class->MissionList[CurrentMission];
TimeOut = mission->Data.Value * (TICKS_PER_MINUTE/10);
Target = TARGET_NONE;
switch (mission->Mission) {
case TMISSION_MOVECELL:
Assign_Mission_Target(::As_Target((CELL)(mission->Data.Value)));
break;
case TMISSION_MOVE:
if ((unsigned)mission->Data.Value < WAYPT_COUNT && Member != NULL) {
FootClass * leader = Fetch_A_Leader();
CELL movecell = Scen.Waypoint[mission->Data.Value];
if (!Is_Leaving_Map()) {
if (leader->Can_Enter_Cell(movecell) != MOVE_OK) {
movecell = Map.Nearby_Location(movecell, leader->Techno_Type_Class()->Speed);
}
}
Assign_Mission_Target(::As_Target(movecell));
Target = ::As_Target(movecell);
}
break;
case TMISSION_ATT_WAYPT:
case TMISSION_PATROL:
case TMISSION_SPY:
if ((unsigned)mission->Data.Value < WAYPT_COUNT) {
Assign_Mission_Target(::As_Target(Scen.Waypoint[mission->Data.Value]));
}
break;
case TMISSION_ATTACKTARCOM:
Assign_Mission_Target(mission->Data.Value);
break;
case TMISSION_UNLOAD:
default:
Assign_Mission_Target(TARGET_NONE);
break;
}
} else {
delete this;
return;
}
}
/*
** Perform mission of the team. This depends on the mission list.
*/
if (Member != NULL && IsMoving && !IsReforming && !IsUnderStrength) {
/*
** If the current Target has been dealt with but the mission target
** has not, then the current target needs to be reset to the mission
** target.
*/
if (!Target_Legal(Target)) {
Target = MissionTarget;
}
/*
** If the current mission is one that times out, then check for
** this case. If it has timed out then advance to the next
** mission in the list or disband the team.
*/
TeamMissionClass const * mission = &Class->MissionList[CurrentMission];
// FootClass * member = Member;
switch (mission->Mission) {
case TMISSION_PATROL:
TMission_Patrol();
break;
case TMISSION_FORMATION:
TMission_Formation();
break;
case TMISSION_ATTACKTARCOM:
case TMISSION_ATTACK:
TMission_Attack();
break;
case TMISSION_LOAD:
TMission_Load();
break;
case TMISSION_DEPLOY:
TMission_Deploy();
break;
case TMISSION_UNLOAD:
TMission_Unload();
break;
case TMISSION_MOVE:
case TMISSION_MOVECELL:
Coordinate_Move();
break;
/*
** All members of this team become invulnerable as if by magic.
*/
case TMISSION_INVULNERABLE:
TMission_Invulnerable();
break;
case TMISSION_GUARD:
Coordinate_Regroup();
break;
case TMISSION_DO:
Coordinate_Do();
break;
case TMISSION_SET_GLOBAL:
TMission_Set_Global();
break;
case TMISSION_ATT_WAYPT:
if (!Target_Legal(MissionTarget)) {
Assign_Mission_Target(TARGET_NONE);
IsNextMission = true;
} else {
Coordinate_Attack();
}
break;
case TMISSION_SPY:
TMission_Spy();
break;
case TMISSION_HOUND_DOG:
TMission_Follow();
break;
case TMISSION_LOOP:
TMission_Loop();
break;
}
/*
** Check for mission time out condition. If the mission does in fact time out, then
** flag it so that the team mission list will advance.
*/
switch (mission->Mission) {
// case TMISSION_UNLOAD:
case TMISSION_GUARD:
if (TimeOut == 0) {
IsNextMission = true;
}
break;
}
} else {
if (IsMoving) {
IsReforming = !Coordinate_Regroup();
} else {
Coordinate_Move();
}
}
}
/***********************************************************************************************
* TeamClass::Add -- Adds specified object to team. *
* *
* Use this routine to add the specified object to the team. The object is checked to make *
* sure that it can be assigned to the team. If it can't, then the object will be left *
* alone and false will be returned. *
* *
* INPUT: obj -- Pointer to the object that is to be assigned to this team. *
* *
* OUTPUT: bool; Was the unit added to the team? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/29/1994 JLB : Created. *
* 01/02/1995 JLB : Initiation flag setup. *
* 08/06/1995 JLB : Allows member stealing from lesser priority teams. *
*=============================================================================================*/
bool TeamClass::Add(FootClass * obj)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
if (!obj) return(false);
int typeindex;
if (!Can_Add(obj, typeindex)) return(false);
/*
** All is ok to add the object to the team, but if the object is already part of
** another team, then it must be removed from that team first.
*/
if (obj->Team.Is_Valid()) {
obj->Team->Remove(obj);
}
/*
** Actually add the object to the team.
*/
Quantity[typeindex]++;
obj->IsInitiated = (Member == NULL);
obj->Member = Member;
Member = obj;
obj->Team = this;
/*
** If a common trigger is designated for this team type, then attach the
** trigger to this team member.
*/
if (Trigger.Is_Valid()) {
obj->Attach_Trigger(Trigger);
}
Total++;
Risk += obj->Risk();
if (Zone == TARGET_NONE) {
Calc_Center(Zone, ClosestMember);
}
/*
** Return with success, since the object was added to the team.
*/
IsAltered = JustAltered = true;
return(true);
}
/***********************************************************************************************
* TeamClass::Can_Add -- Determines if the specified object can be added to team. *
* *
* This routine will examine the team and determine if the specified object can be *
* properly added to this team. This is a security check to filter out those objects that *
* should not be added because of conflicting priorities or other restrictions. *
* *
* INPUT: obj -- Pointer to the candidate object that is being checked for legal *
* adding to this team. *
* *
* typeindex-- The class index number (according to the team type's class array) that *
* the candidate object is classified as. The routine processes much *
* faster if you can provide this information, but if you don't, the *
* routine will figure it out. *
* *
* OUTPUT: bool; Can the specified object be added to this team? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 02/27/1996 JLB : Created. *
*=============================================================================================*/
bool TeamClass::Can_Add(FootClass * obj, int & typeindex) const
{
assert(IsActive);
assert(Teams.ID(this) == ID);
/*
** Trying to add the team member to itself is an error condition.
*/
if (obj->Team == this) {
return(false);
}
/*
** The object must be active, a member of this house. A special dispensation is given to
** units that are in radio contact. It is presumed that they are very busy and should
** not be disturbed.
*/
if (!_Is_It_Breathing(obj) || obj->In_Radio_Contact() || obj->House != House) {
return(false);
}
/*
** If the object is doing some mission that precludes it from joining
** a team then don't add it.
*/
if (obj->Mission != MISSION_NONE && !MissionClass::Is_Recruitable_Mission(obj->Mission)) {
return(false);
}
/*
** If this object is part of another team, then check to make sure that it
** is permitted to leave the other team in order to join this one. If not,
** then no further processing is allowed -- bail.
*/
if (obj->Team.Is_Valid() && (obj->Team->Class->RecruitPriority >= Class->RecruitPriority)) {
return(false);
}
/*
** Aircraft that have no ammo for their weapons cannot be recruited into a team.
*/
if (obj->What_Am_I() == RTTI_AIRCRAFT && obj->Techno_Type_Class()->PrimaryWeapon != NULL && !obj->Ammo) {
return(false);
}
/*
** Search for the exact member index that the candidate object matches.
** If no match could be found, then adding the object to the team cannot
** occur.
*/
for (typeindex = 0; typeindex < Class->ClassCount; typeindex++) {
if (Class->Members[typeindex].Class == &obj->Class_Of()) {
break;
}
}
if (typeindex == Class->ClassCount) {
return(false);
}
/*
** If the team is already full of this type, then adding the object is not allowed.
** Return with a failure flag in this case.
*/
if (Quantity[typeindex] >= Class->Members[typeindex].Quantity) {
return(false);
}
return(true);
}
/***********************************************************************************************
* TeamClass::Remove -- Removes the specified object from the team. *
* *
* Use this routine to remove an object from a team. Objects removed from the team are *
* then available to be recruited by other teams, or even by the same team at a later time. *
* *
* INPUT: obj -- Pointer to the object that is to be removed from this team. *
* *
* typeindex-- Optional index of where this object type is specified in the type *
* type class. This parameter can be omitted. It only serves to make *
* the removal process faster. *
* *
* OUTPUT: bool; Was the object removed from this team? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/29/1994 JLB : Created. *
* 01/02/1995 JLB : Initiation tracking and team captain selection. *
*=============================================================================================*/
bool TeamClass::Remove(FootClass * obj, int typeindex)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
/*
** Make sure that the object is in fact a member of this team. If not, then it can't
** be removed. Return success because the end result is the same.
*/
if (this != obj->Team) {
return(true);
}
/*
** Detach the common trigger for this team type. Only current and active members of the
** team have that trigger attached. The exception is for player team members that
** get removed from a reinforcement team.
*/
if (obj->Trigger == Trigger && !obj->House->IsPlayerControl) {
obj->Attach_Trigger(NULL);
}
/*
** If the proper team index was not provided, then find it in the type type class. The
** team type class will not be set if the appropriate type could not be found
** for this object. This indicates that the object was illegally added. Continue to
** process however, since removing this object from the team is a good idea.
*/
if (typeindex == -1) {
for (typeindex = 0; typeindex < Class->ClassCount; typeindex++) {
if (Class->Members[typeindex].Class == &obj->Class_Of()) {
break;
}
}
}
/*
** Decrement the counter for the team class. There is now one less of this object type.
*/
if (typeindex < Class->ClassCount) {
Quantity[typeindex]--;
}
/*
** Actually remove the object from the team. Scan through the team members
** looking for the one that matches the one specified. If it is found, it
** is unlinked from the member chain. During this scan, a check is made to
** ensure that at least one remaining member is still initiated. If not, then
** a new team captain must be chosen.
*/
bool initiated = false;
FootClass * prev = 0;
FootClass * curr = Member;
bool found = false;
while (curr != NULL && (!found || !initiated)) {
if (curr == obj) {
if (prev != NULL) {
prev->Member = curr->Member;
} else {
Member = curr->Member;
}
FootClass * temp = curr->Member;
curr->Member = 0;
curr->Team = 0;
curr->SuspendedMission = MISSION_NONE;
curr->SuspendedNavCom = TARGET_NONE;
curr->SuspendedTarCom = TARGET_NONE;
curr = temp;
Total--;
found = true;
Risk -= obj->Risk();
continue;
}
/*
** If this (remaining) member is initiated, then keep a record of this.
*/
initiated |= curr->IsInitiated;
prev = curr;
curr = curr->Member;
}
/*
** A unit that breaks off of a team will enter idle mode.
*/
obj->Enter_Idle_Mode();
/*
** If, after removing the team member, there are no initiated members left
** in the team, then just make the first remaining member of the team the
** team captain. Mark the center location of the team as invalid so that
** it will be centered around the captain.
*/
if (!initiated && Member != NULL) {
Member->IsInitiated = true;
Zone = TARGET_NONE;
}
/*
** Must record that the team composition has changed. At the next opportunity,
** the team members will be counted and appropriate AI adjustments made.
*/
IsAltered = JustAltered = true;
return(true);
}
/***********************************************************************************************
* TeamClass::Recruit -- Attempts to recruit members to the team for the given index ID. *
* *
* This routine will take the given index ID and scan for available objects of that type *
* to recruit to the team. Recruiting will continue until that object type has either *
* been exhausted or if the team's requirement for that type has been filled. *
* *
* INPUT: typeindex -- The index for the object type to recruit. The index is used to *
* look into the type type's array of object types that make up this *
* team. *
* *
* OUTPUT: Returns with the number of objects added to this team. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/29/1994 JLB : Created. *
* 04/10/1995 JLB : Scans for units too. *
*=============================================================================================*/
int TeamClass::Recruit(int typeindex)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
COORDINATE center = As_Coord(Zone);
if (Class->Origin != -1) {
center = Cell_Coord(Scen.Waypoint[Class->Origin]);
}
int added = 0; // Total number added to team.
/*
** Quick check to see if recruiting is really allowed for this index or not.
*/
if (Class->Members[typeindex].Quantity > Quantity[typeindex]) {
switch (Class->Members[typeindex].Class->What_Am_I()) {
/*
** For infantry objects, sweep through the infantry in the game looking for
** ones owned by the house that owns the team. When found, try to add.
*/
case RTTI_INFANTRYTYPE:
case RTTI_INFANTRY:
{
InfantryClass * best = 0;
int bestdist = -1;
for (int index = 0; index < Infantry.Count(); index++) {
InfantryClass * infantry = Infantry.Ptr(index);
int d = infantry->Distance(center);
if ((d < bestdist || bestdist == -1) && Can_Add(infantry, typeindex)) {
best = infantry;
bestdist = d;
}
}
if (best) {
best->Assign_Target(TARGET_NONE);
Add(best);
added++;
}
}
break;
case RTTI_AIRCRAFTTYPE:
case RTTI_AIRCRAFT:
{
AircraftClass * best = 0;
int bestdist = -1;
for (int index = 0; index < Aircraft.Count(); index++) {
AircraftClass * aircraft = Aircraft.Ptr(index);
int d = aircraft->Distance(center);
if ((d < bestdist || bestdist == -1) && Can_Add(aircraft, typeindex)) {
best = aircraft;
bestdist = d;
}
}
if (best) {
best->Assign_Target(TARGET_NONE);
Add(best);
added++;
}
}
break;
case RTTI_UNITTYPE:
case RTTI_UNIT:
{
UnitClass * best = 0;
int bestdist = -1;
for (int index = 0; index < Units.Count(); index++) {
UnitClass * unit = Units.Ptr(index);
int d = unit->Distance(center);
if (unit->House == House && unit->Class == Class->Members[typeindex].Class) {
if ((d < bestdist || bestdist == -1) && Can_Add(unit, typeindex)) {
best = unit;
bestdist = d;
}
}
if (best) {
best->Assign_Target(TARGET_NONE);
Add(best);
added++;
/*
** If a transport is added to the team, the occupants
** are added by default.
*/
FootClass * f = best->Attached_Object();
while (f) {
Add(f);
f = (FootClass *)(ObjectClass *)f->Next;
}
}
}
}
break;
case RTTI_VESSELTYPE:
case RTTI_VESSEL:
{
VesselClass * best = 0;
int bestdist = -1;
for (int index = 0; index < Vessels.Count(); index++) {
VesselClass * vessel = Vessels.Ptr(index);
int d = vessel->Distance(center);
if (vessel->House == House && vessel->Class == Class->Members[typeindex].Class) {
if ((d < bestdist || bestdist == -1) && Can_Add(vessel, typeindex)) {
best = vessel;
bestdist = d;
}
}
if (best) {
best->Assign_Target(TARGET_NONE);
Add(best);
added++;
/*
** If a transport is added to the team, the occupants
** are added by default.
*/
FootClass * f = best->Attached_Object();
while (f) {
Add(f);
f = (FootClass *)(ObjectClass *)f->Next;
}
}
}
}
break;
}
}
return(added);
}
/***********************************************************************************************
* TeamClass::Detach -- Removes specified target from team tracking. *
* *
* When a target object is about to be removed from the game (e.g., it was killed), then *
* any team that is looking at that target must abort from that target. *
* *
* INPUT: target -- The target object that is going to be removed from the game. *
* *
* all -- Is the target going away for good as opposed to just cloaking/hiding? *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/29/1994 JLB : Created. *
*=============================================================================================*/
void TeamClass::Detach(TARGET target, bool )
{
assert(IsActive);
assert(Teams.ID(this) == ID);
/*
** If the target to detach matches the target of this team, then remove
** the target from this team's Tar/Nav com and let the chips fall
** where they may.
*/
if (Target == target) {
Target = TARGET_NONE;
}
if (MissionTarget == target) {
MissionTarget = TARGET_NONE;
}
if (Trigger.Is_Valid() && Trigger->As_Target() == target) {
Trigger = 0;
}
}
/***********************************************************************************************
* TeamClass::Calc_Center -- Determines average location of team members. *
* *
* Use this routine to calculate the "center" location of the team. This is the average *
* position of all members of the team. Using this center value it is possible to tell *
* if a team member is too far away and where to head to in order to group up. *
* *
* INPUT: center -- Average center target location of the team. Only initiated members *
* will be considered. *
* *
* close_member--Location (as target) of the unit that is closest to the team's *
* target. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/29/1994 JLB : Created. *
*=============================================================================================*/
void TeamClass::Calc_Center(TARGET & center, TARGET & close_member) const
{
assert(IsActive);
assert(Teams.ID(this) == ID);
/*
** Presume there is no center. This will be confirmed in the following scanning
** operation.
*/
close_member = TARGET_NONE;
center = TARGET_NONE;
FootClass const * team_member = Member; // Working team member pointer.
/*
** If there are no members of the team, then there can be no center point of the team.
*/
if (team_member == NULL) return;
/*
** If the team is supposed to follow a nearby friendly unit, then the
** team's "center" will actually be that unit. Otherwise, calculated the
** average center location for the team.
*/
if (Class->MissionList[CurrentMission].Mission == TMISSION_HOUND_DOG) {
/*
** First pick a member of the team. The closest friendly object to that member
** will be picked.
*/
if (!team_member) return;
FootClass const * closest = NULL; // Current closest friendly object.
int distance = -1; // Record of last closest distance calc.
/*
** Scan through all vehicles.
*/
for (int unit_index = 0; unit_index < Units.Count(); unit_index++) {
FootClass const * trial_unit = Units.Ptr(unit_index);
if (_Is_It_Breathing(trial_unit) && trial_unit->House->Is_Ally(House) && trial_unit->Team != this) {
int trial_distance = team_member->Distance(trial_unit);
if (distance == -1 || trial_distance < distance) {
distance = trial_distance;
closest = trial_unit;
}
}
}
/*
** Scan through all infantry.
*/
for (int infantry_index = 0; infantry_index < Infantry.Count(); infantry_index++) {
FootClass const * trial_infantry = Infantry.Ptr(infantry_index);
if (_Is_It_Breathing(trial_infantry) && trial_infantry->House->Is_Ally(House) && trial_infantry->Team != this) {
int trial_distance = team_member->Distance(trial_infantry);
if (distance == -1 || trial_distance < distance) {
distance = trial_distance;
closest = trial_infantry;
}
}
}
/*
** Scan through all vessels.
*/
for (int vessel_index = 0; vessel_index < Vessels.Count(); vessel_index++) {
FootClass const * trial_vessel = Vessels.Ptr(vessel_index);
if (_Is_It_Breathing(trial_vessel) && trial_vessel->House->Is_Ally(House) && trial_vessel->Team != this) {
int trial_distance = team_member->Distance(trial_vessel);
if (distance == -1 || trial_distance < distance) {
distance = trial_distance;
closest = trial_vessel;
}
}
}
/*
** Set the center location as actually the friendly object that is closest. If there
** is no friendly object, then don't set any center location at all.
*/
if (closest) {
center = closest->As_Target();
close_member = Member->As_Target();
}
} else {
long x = 0; // Accumulated X coordinate.
long y = 0; // Accumulated Y coordinate.
int dist = 0; // Closest recorded distance to team target.
int quantity = 0; // Number of team members counted.
FootClass const * closest = 0; // Closest member to target.
/*
** Scan through all team members and accumulate the X and Y component of their
** location. Only team members that are active will be considered. Also keep
** track of the team member that is closest to the team's target.
*/
while (team_member != NULL) {
if (_Is_It_Playing(team_member)) {
/*
** Accumulate X and Y components of qualified team members.
*/
x += Coord_X(team_member->Coord);
y += Coord_Y(team_member->Coord);
quantity++;
/*
** Keep a record of the team member that is nearest to the team's
** target.
*/
int try_dist = team_member->Distance(Target);
if (!dist || try_dist < dist) {
dist = try_dist;
closest = team_member;
}
}
team_member = team_member->Member;
}
/*
** If there were any qualifying members, then the team's center point can be
** determined.
*/
if (quantity) {
x /= quantity;
y /= quantity;
COORDINATE coord = XY_Coord((int)x, (int)y);
center = ::As_Target(coord);
/*
** If the center location is impassable, then just pick the location of
** one of the team members.
*/
if (!closest->Can_Enter_Cell(As_Cell(center))) {
// if (Class->Origin != -1) {
// center = ::As_Target(Scen.Waypoint[Class->Origin]);
// } else {
center = ::As_Target(Coord_Cell(closest->Center_Coord()));
// }
}
}
/*
** Record the position of the closest member to the team's target and
** that will be used as the regroup point.
*/
if (closest != NULL) {
close_member = ::As_Target(Coord_Cell(closest->Center_Coord()));
}
}
}
/***********************************************************************************************
* TeamClass::Took_Damage -- Informs the team when the team member takes damage. *
* *
* This routine is used when a team member takes damage. Usually the team will react in *
* some fashion to the attack. This reaction can range from running away to assigning this *
* new target as the team's target. *
* *
* INPUT: obj -- The team member that was damaged. *
* *
* result -- The severity of the damage taken. *
* *
* source -- The perpetrator of the damage. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/29/1994 JLB : Created. *
*=============================================================================================*/
void TeamClass::Took_Damage(FootClass * , ResultType result, TechnoClass * source)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
if ((result != RESULT_NONE) && (!Class->IsSuicide)) {
if (!IsMoving) {
// TCTCTC
// Should run to a better hiding place or disband into a group of hunting units.
} else {
/*
** Respond to the attack, but not if we're an aircraft or a LST.
*/
if (source && !Is_A_Member(source) && Member && Member->What_Am_I() != RTTI_AIRCRAFT && (Member->What_Am_I() != RTTI_VESSEL || *(VesselClass *)((FootClass *)Member) != VESSEL_TRANSPORT)) {
if (Target != source->As_Target()) {
/*
** Don't change target if the team's target is one that can fire as well. There is
** no point in endlessly shuffling between targets that have firepower.
*/
if (Target_Legal(Target)) {
TechnoClass * techno = As_Techno(Target);
if (techno && ((TechnoTypeClass const &)techno->Class_Of()).PrimaryWeapon != NULL) {
if (techno->In_Range(As_Coord(Zone), 0)) {
return;
}
}
}
/*
** Don't change target to aggressor if the aggressor cannot normally be attacked.
*/
if (source->What_Am_I() == RTTI_AIRCRAFT || (source->What_Am_I() == RTTI_VESSEL && (Member->What_Am_I() == RTTI_UNIT || Member->What_Am_I() == RTTI_INFANTRY))) {
return;
}
Target = source->As_Target();
}
}
}
}
}
/***********************************************************************************************
* TeamClass::Coordinate_Attack -- Handles coordinating a team attack. *
* *
* This function is called when the team knows what it should attack. This routine will *
* give the necessary orders to the members of the team. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 04/06/1995 JLB : Created. *
*=============================================================================================*/
void TeamClass::Coordinate_Attack(void)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
if (!Target_Legal(Target)) {
Target = MissionTarget;
}
/*
** Check if they're attacking a cell. If the contents of the cell are
** a bridge or a building/unit/techno, then it's a valid target. Otherwise,
** the target is invalid. This only applies to non-aircraft teams. An aircraft team
** can "attack" an empty cell and this is perfectly ok (paratrooper drop and parabombs
** are prime examples).
*/
if (Is_Target_Cell(Target) && Member != NULL && Fetch_A_Leader()->What_Am_I() != RTTI_AIRCRAFT) {
CellClass *cellptr = &Map[As_Cell(Target)];
TemplateType tt = cellptr->TType;
if (cellptr->Cell_Object()) {
Target = cellptr->Cell_Object()->As_Target();
} else {
if (tt != TEMPLATE_BRIDGE1 && tt != TEMPLATE_BRIDGE2 &&
tt != TEMPLATE_BRIDGE1H && tt != TEMPLATE_BRIDGE2H &&
tt != TEMPLATE_BRIDGE_1A && tt != TEMPLATE_BRIDGE_1B &&
tt != TEMPLATE_BRIDGE_2A && tt != TEMPLATE_BRIDGE_2B &&
tt != TEMPLATE_BRIDGE_3A && tt != TEMPLATE_BRIDGE_3B ) {
#ifdef FIXIT_CSII // checked - ajw 9/28/98
FootClass *unit = Member;
TeamMissionClass const * mission = &Class->MissionList[CurrentMission];
if(unit->What_Am_I() != RTTI_UNIT ||
*(UnitClass *)unit != UNIT_CHRONOTANK ||
mission->Mission != TMISSION_SPY)
#endif
Target = 0; // invalidize the target so it'll go to next mission.
}
}
}
if (!Target_Legal(Target)) {
IsNextMission = true;
} else {
TeamMissionClass const * mission = &Class->MissionList[CurrentMission];
FootClass * unit = Member;
while (unit != NULL) {
Coordinate_Conscript(unit);
if (_Is_It_Playing(unit)) {
if (mission->Mission == TMISSION_SPY && unit->What_Am_I() == RTTI_INFANTRY && *(InfantryClass *)unit == INFANTRY_SPY) {
unit->Assign_Mission(MISSION_CAPTURE);
unit->Assign_Target(Target);
} else {
#ifdef FIXIT_CSII // checked - ajw 9/28/98
if (mission->Mission == TMISSION_SPY && unit->What_Am_I() == RTTI_UNIT && *(UnitClass *)unit == UNIT_CHRONOTANK) {
UnitClass *tank = (UnitClass *)unit;
tank->Teleport_To(::As_Cell(Target));
tank->MoebiusCountDown = ChronoTankDuration * TICKS_PER_MINUTE;
Scen.Do_BW_Fade();
Sound_Effect(VOC_CHRONOTANK1, unit->Coord);
tank->Assign_Target(TARGET_NONE);
tank->Assign_Mission(MISSION_GUARD);
} else {
#endif
if (unit->Mission != MISSION_ATTACK && unit->Mission != MISSION_ENTER && unit->Mission != MISSION_CAPTURE) {
unit->Transmit_Message(RADIO_OVER_OUT);
unit->Assign_Mission(MISSION_ATTACK);
unit->Assign_Target(TARGET_NONE);
unit->Assign_Destination(TARGET_NONE);
}
}
#ifdef FIXIT_CSII // checked - ajw 9/28/98
}
#endif
if (unit->TarCom != Target) {
unit->Assign_Target(Target);
}
}
unit = unit->Member;
}
}
}
/***********************************************************************************************
* TeamClass::Coordinate_Regroup -- Handles team idling (regrouping). *
* *
* This routine is called when the team must delay at its current location. Team members *
* are grouped together by this function. It is called when the team needs to sit and *
* wait. *
* *
* INPUT: none *
* *
* OUTPUT: bool; Has the team completely regrouped? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 04/06/1995 JLB : Created. *
*=============================================================================================*/
bool TeamClass::Coordinate_Regroup(void)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
FootClass * unit = Member;
bool retval = true;
/*
** Regroup default logic.
*/
while (unit != NULL) {
Coordinate_Conscript(unit);
if (_Is_It_Playing(unit)) {
if (unit->Distance(Zone) > Rule.StrayDistance && (unit->Mission != MISSION_GUARD_AREA || !Target_Legal(unit->TarCom))) {
if (!Target_Legal(unit->NavCom)) {
// TCTCTC
// if (!Target_Legal(unit->NavCom) || ::Distance(unit->NavCom, Zone) > Rule.StrayDistance) {
unit->Assign_Mission(MISSION_MOVE);
unit->Assign_Destination(Zone);
retval = false;
if (!unit->IsFormationMove) {
unit->Assign_Mission(MISSION_MOVE);
CELL dest = unit->Adjust_Dest(As_Cell(Zone));
unit->Assign_Destination(::As_Target(dest));
} else {
retval = true; // formations are always considered regrouped.
}
}
} else {
/*
** The team is regrouping, so just sit here and wait.
*/
if (unit->Mission != MISSION_GUARD_AREA) {
unit->Assign_Mission(MISSION_GUARD);
unit->Assign_Destination(TARGET_NONE);
}
}
}
unit = unit->Member;
}
return(retval);
}
/***********************************************************************************************
* TeamClass::Coordinate_Do -- Handles the team performing specified mission. *
* *
* This will assign the specified mission to the team. If there are team members that are *
* too far away from the center of the team, then they will be told to move to the team's *
* location. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: This only works if the special mission the team members are to perform does not *
* require extra parameters. The ATTACK and MOVE missions are particularly bad. *
* *
* HISTORY: *
* 05/11/1996 JLB : Created. *
*=============================================================================================*/
void TeamClass::Coordinate_Do(void)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
FootClass * unit = Member;
MissionType do_mission = Class->MissionList[CurrentMission].Data.Mission;
/*
** For each unit either head it back to the team center or give it the main
** team mission order as appropriate.
*/
while (unit != NULL) {
Coordinate_Conscript(unit);
if (_Is_It_Playing(unit)) {
if (!Target_Legal(unit->TarCom) && !Target_Legal(unit->NavCom) && unit->Distance(Zone) > Rule.StrayDistance * 2) {
/*
** Only if the unit isn't already heading to regroup with the team, will it
** be given orders to do so.
*/
unit->Assign_Mission(MISSION_MOVE);
unit->Assign_Destination(Zone);
unit->Assign_Mission(MISSION_MOVE);
CELL dest = unit->Adjust_Dest(As_Cell(Zone));
unit->Assign_Destination(::As_Target(dest));
} else {
/*
** The team is regrouping, so just sit here and wait.
*/
if (!Target_Legal(unit->TarCom) && !Target_Legal(unit->NavCom) && unit->Mission != do_mission) {
unit->ArchiveTarget = TARGET_NONE;
unit->Assign_Mission(do_mission);
unit->Assign_Target(TARGET_NONE);
unit->Assign_Destination(TARGET_NONE);
}
}
}
unit = unit->Member;
}
}
/***********************************************************************************************
* TeamClass::Coordinate_Move -- Handles team movement coordination. *
* *
* This routine is called when the team must move to a new location. Movement and grouping *
* commands associated with this task are initiated here. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 04/06/1995 JLB : Created. *
*=============================================================================================*/
void TeamClass::Coordinate_Move(void)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
FootClass * unit = Member;
bool finished = true;
bool found = false;
if (!Target_Legal(Target)) {
Target = MissionTarget;
}
if (Target_Legal(Target)) {
if (!Lagging_Units()) {
while (unit != NULL) {
/*
** Tell the unit, if necessary, that it should regroup
** with the main team location. If the unit is regrouping, then
** the team should continue NOT qualify as fully reaching the desired
** location.
*/
if (Coordinate_Conscript(unit)) {
finished = false;
}
if (unit->Mission == MISSION_UNLOAD || unit->MissionQueue == MISSION_UNLOAD) {
finished = false;
}
if (_Is_It_Playing(unit) && unit->Mission != MISSION_UNLOAD && unit->MissionQueue != MISSION_UNLOAD) {
int stray = Rule.StrayDistance;
if (unit->What_Am_I() == RTTI_AIRCRAFT) {
stray *= 3;
}
if (unit->What_Am_I() == RTTI_INFANTRY && ((InfantryClass const *)unit)->Class->IsDog) {
if (Target_Legal(unit->TarCom)) stray = unit->Techno_Type_Class()->ThreatRange;
if (Target_Legal(unit->TarCom) && unit->Distance(unit->TarCom) > stray) {
unit->Assign_Target(TARGET_NONE);
}
}
found = true;
int dist = unit->Distance(Target);
if (unit->IsFormationMove) {
if (::As_Target(Coord_Cell(unit->Coord)) != unit->NavCom) {
dist = Rule.StrayDistance + 1; // formation moves must be exact.
}
}
if (dist > stray ||
(unit->What_Am_I() == RTTI_AIRCRAFT &&
// (unit->In_Which_Layer() == LAYER_TOP &&
((AircraftClass *)unit)->Height > 0 &&
Coord_Cell(unit->Center_Coord()) != As_Cell(Target) &&
!((AircraftClass *)unit)->Class->IsFixedWing &&
Class->MissionList[CurrentMission+1].Mission != TMISSION_MOVE)) {
bool wasform = false;
if (unit->Mission != MISSION_MOVE) {
unit->Assign_Mission(MISSION_MOVE);
}
if (unit->NavCom != Target) {
/*
** Check if this destination should be adjusted for
** a formation move
*/
if (Is_Target_Cell(Target) && unit->IsFormationMove) {
CELL newcell = unit->Adjust_Dest(As_Cell(Target));
if (Coord_Cell(unit->Coord) != newcell) {
unit->Assign_Destination(::As_Target(newcell));
} else {
unit->Assign_Mission(MISSION_GUARD);
unit->Assign_Destination(TARGET_NONE);
wasform = true;
}
} else {
unit->Assign_Destination(Target);
}
}
if (!wasform) {
finished = false;
}
} else {
if (unit->Mission == MISSION_MOVE && (!Target_Legal(unit->NavCom) || Distance(unit->NavCom) < CELL_LEPTON_W)) {
unit->Assign_Destination(TARGET_NONE);
unit->Enter_Idle_Mode();
}
}
/*
** If any member still has a valid NavCom then consider this
** movement mission to still be in progress. This will ensure
** that the members come to a complete stop before the next
** mission commences. Without this, the team will prematurely
** start on the next mission even when all members aren't yet
** in their proper spot.
*/
if (Target_Legal(unit->NavCom)) {
finished = false;
}
}
unit = unit->Member;
}
} else {
finished = false;
}
}
/*
** If there are no initiated members to this team, then it certainly
** could not have managed to move to the target destination.
*/
if (!found) {
finished = false;
}
/*
** If all the team members are close enough to the desired destination, then
** move to the next mission.
*/
if (finished && IsMoving) {
IsNextMission = true;
}
}
/***********************************************************************************************
* TeamClass::Lagging_Units -- Finds and orders any lagging units to catch up. *
* *
* This routine will examine the team and find any lagging units. The units are then *
* ordered to catch up to the team member that is closest to the team's destination. This *
* routine will not do anything unless lagging members are suspected. This fact is *
* indicated by setting the IsLagging flag. The flag is set by some outside agent. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: Be sure to set IsLagging for the team if a lagging member is suspected. *
* *
* HISTORY: *
* 08/01/1995 PWG : Created. *
* 04/11/1996 JLB : Modified. *
*=============================================================================================*/
bool TeamClass::Lagging_Units(void)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
FootClass * unit = Member;
bool lag = false;
//BG: HACK - if it's in a formation move, then disable the check for
// VG added NULL check laggers, 'cause they're all moving simultaneously.
if (unit != NULL && unit->IsFormationMove) IsLagging = false;
/*
** If the IsLagging bit is not set, then obviously there are no lagging
** units.
*/
if (!IsLagging) return(false);
/*
** Scan through all of the units, searching for units who are having
** trouble keeping up with the pack.
*/
while (unit != NULL) {
if (_Is_It_Playing(unit)) {
int stray = Rule.StrayDistance;
if (unit->What_Am_I() == RTTI_AIRCRAFT) {
stray *= 3;
}
/*
** If we find a unit who has fallen too far away from the center of
** the pack, then we need to order that unit to catch up with the
** first unit.
*/
if (unit->Distance(ClosestMember) > stray) {
// TCTCTC
if (!Target_Legal(unit->NavCom)) {
// if (!Target_Legal(unit->NavCom) || ::Distance(unit->NavCom, ClosestMember) > Rule.StrayDistance) {
unit->Assign_Mission(MISSION_MOVE);
unit->Assign_Destination(ClosestMember);
}
lag = true;
} else {
/*
** We need to order all of the other units to hold their
** position until all lagging units catch up.
*/
if (unit->Mission != MISSION_GUARD) {
unit->Assign_Mission(MISSION_GUARD);
unit->Assign_Destination(TARGET_NONE);
}
}
}
unit = unit->Member;
}
/*
** Once we have handled the loop we know whether there are any lagging
** units or not.
*/
IsLagging = lag;
return(lag);
}
/***********************************************************************************************
* TeamClass::TMission_Unload -- Tells the team to unload passengers now. *
* *
* This routine tells all transport vehicles to unload passengers now. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/14/1995 JLB : Created. *
*=============================================================================================*/
int TeamClass::TMission_Unload(void)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
FootClass * unit = Member;
bool finished = true;
while (unit != NULL) {
Coordinate_Conscript(unit);
if (_Is_It_Playing(unit)) {
/*
** Only assign the mission if the unit is carrying a passenger, OR
** if the unit is a minelayer, with mines in it, and the cell it's
** on doesn't have a building (read: mine) in it already.
*/
#ifdef FIXIT_CSII // checked - ajw 9/28/98
/* Also, allow unload if it's a MAD Tank. */
if (unit->Is_Something_Attached() || (unit->What_Am_I() == RTTI_UNIT && *(UnitClass *)unit == UNIT_MINELAYER && unit->Ammo) || (unit->What_Am_I() == RTTI_UNIT && *(UnitClass *)unit == UNIT_MAD )) {
#else
if (unit->Is_Something_Attached() || (unit->What_Am_I() == RTTI_UNIT && *(UnitClass *)unit == UNIT_MINELAYER && unit->Ammo) ) {
#endif
if (unit->Is_Something_Attached()) {
/*
** Passenger-carrying vehicles will always return false until
** they've unloaded all passengers.
*/
finished = false;
}
/*
** The check for a building is located here because the mine layer may have
** already unloaded the mine but is still in the process of retracting
** the mine layer. During this time, it should not be considered to have
** finished its unload mission.
*/
if (Map[unit->Center_Coord()].Cell_Building() == NULL && unit->Mission != MISSION_UNLOAD) {
unit->Assign_Destination(TARGET_NONE);
unit->Assign_Target(TARGET_NONE);
unit->Assign_Mission(MISSION_UNLOAD);
finished = false;
}
} else {
/*
** A loaner transport should vacate the map when all transported objects
** have been offloaded.
*/
if (unit->IsALoaner) {
Remove(unit);
unit->Assign_Mission(MISSION_RETREAT);
unit->Commence();
}
}
}
unit = unit->Member;
}
if (finished) {
IsNextMission = true;
}
return(1);
}
/***********************************************************************************************
* TeamClass::TMission_Load -- Tells the team to load onto the transport now. *
* *
* This routine tells all non-transport units in the team to climb onto the transport in the*
* team. Note the transport must be a member of this team. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/28/1996 BWG : Created. *
*=============================================================================================*/
int TeamClass::TMission_Load(void)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
FootClass * unit = Member;
FootClass * trans = 0;
/*
** First locate the transport in the team, if there is one. There should
** only be one transport in the team.
*/
while(unit != NULL && trans == NULL) {
if (unit->Techno_Type_Class()->Max_Passengers() > 0) {
trans = unit;
break;
}
unit = unit->Member;
}
/*
** In the case of no transport available, then consider the mission complete
** since it can never complete otherwise.
*/
if (trans == NULL) {
IsNextMission = true;
return(1);
}
/*
** If the transport is already in radio contact, then this means that
** it is in the process of loading. During this time, don't bother to assign
** the enter mission to the other team members.
*/
if (trans->In_Radio_Contact()) {
return(1);
}
/*
** Find a member to assign the entry logic for.
*/
bool finished = true;
unit = Member; // re-point at the first member of the team again.
while (unit != NULL && Total > 1) {
Coordinate_Conscript(unit);
/*
** Only assign the mission if the unit is not the transport.
*/
if (_Is_It_Playing(unit) && unit != trans) {
if (unit->Mission != MISSION_ENTER) {
unit->Assign_Mission(MISSION_ENTER);
unit->Assign_Target(TARGET_NONE);
unit->Assign_Destination(trans->As_Target());
finished = false;
break;
}
finished = false;
}
unit = unit->Member;
}
if (finished) {
IsNextMission = true;
}
return(1);
}
/***********************************************************************************************
* TeamClass::Coordinate_Conscript -- Gives orders to new recruit. *
* *
* This routine will give the movement orders to the conscript so that it will group *
* with the other members of the team. *
* *
* INPUT: unit -- Pointer to the conscript unit. *
* *
* OUTPUT: bool; Is the unit still scurrying to reach the team's current location? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 04/06/1995 JLB : Created. *
*=============================================================================================*/
bool TeamClass::Coordinate_Conscript(FootClass * unit)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
if (_Is_It_Breathing(unit) && !unit->IsInitiated) {
if (unit->Distance(Zone) > Rule.StrayDistance) {
if (!Target_Legal(unit->NavCom)) {
unit->Assign_Mission(MISSION_MOVE);
unit->Assign_Target(TARGET_NONE);
unit->IsFormationMove = false;
unit->Assign_Destination(Zone);
}
return(true);
} else {
/*
** This unit has gotten close enough to the team center so that it is
** now considered initiated. An initiated unit is considered when calculating
** the center of the team.
*/
unit->IsInitiated = true;
}
}
return(false);
}
/***************************************************************************
* TeamClass::Is_A_Member -- Tests if a unit is a member of a team *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: *
* *
* HISTORY: *
* 05/16/1995 PWG : Created. *
*=========================================================================*/
bool TeamClass::Is_A_Member(void const * who) const
{
assert(IsActive);
assert(Teams.ID(this) == ID);
FootClass * unit = Member;
while (unit != NULL) {
if (unit == who) {
return(true);
}
unit = unit->Member;
}
return(false);
}
/***************************************************************************
* TeamClass::Suspend_Teams -- Suspends activity for low priority teams *
* *
* INPUT: int priority - determines what is considered low priority. *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 06/19/1995 PWG : Created. *
*=========================================================================*/
void TeamClass::Suspend_Teams(int priority, HouseClass const * house)
{
for (int index = 0; index < Teams.Count(); index++) {
TeamClass * team = Teams.Ptr(index);
/*
** If a team is below the "survival priority level", then it gets
** destroyed. The team members are then free to be reassigned.
*/
if (team != NULL && team->House == house && team->Class->RecruitPriority < priority) {
FootClass * unit = team->Member;
while (team->Member) {
team->Remove(team->Member);
}
team->IsAltered = team->JustAltered = true;
team->SuspendTimer = Rule.SuspendDelay * TICKS_PER_MINUTE;
team->Suspended = true;
}
}
}
/***********************************************************************************************
* TeamClass::Is_Leaving_Map -- Checks if team is in process of leaving the map *
* *
* This routine is used to see if the team is leaving the map. A team that is leaving the *
* map gives implicit permission for its members to leave the map. *
* *
* INPUT: none *
* *
* OUTPUT: bool; Is this team trying to leave the map? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 04/30/1996 JLB : Created. *
*=============================================================================================*/
bool TeamClass::Is_Leaving_Map(void) const
{
assert(IsActive);
assert(Teams.ID(this) == ID);
if (IsMoving && CurrentMission >= 0) {
TeamMissionClass const * mission = &Class->MissionList[CurrentMission];
if (mission->Mission == TMISSION_MOVE && !Map.In_Radar(Scen.Waypoint[mission->Data.Value])) {
return(true);
}
}
return(false);
}
/***********************************************************************************************
* TeamClass::Has_Entered_Map -- Determines if the entire team has entered the map. *
* *
* This will examine all team members and only if all of them have entered the map, will *
* it return true. This routine is used to recognize the case of a team that has been *
* generated off map and one that has already entered game play. This knowledge can lead *
* to more intelligent behavior regarding team and member disposition. *
* *
* INPUT: none *
* *
* OUTPUT: bool; Have all members of this team entered the map? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/26/1996 JLB : Created. *
*=============================================================================================*/
bool TeamClass::Has_Entered_Map(void) const
{
bool ok = true;
FootClass * foot = Member;
while (foot != NULL) {
if (!foot->IsLocked) {
ok = false;
break;
}
foot = (FootClass *)(ObjectClass *)(foot->Next);
}
return(ok);
}
/***********************************************************************************************
* TeamClass::Scan_Limit -- Force all members of the team to have limited scan range. *
* *
* This routine is used when one of the team members cannot get within range of the team's *
* target. In such a case, the team must be assigned a new target and all members of that *
* team must recognize that a restricted target scan is required. This is done by clearing *
* out the team's target so that it will be forced to search for a new one. Also, since the *
* members are flagged for short scanning, whichever team member is picked to scan for a *
* target will scan for one that is within range. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: The team will reassign its target as a result of this routine. *
* *
* HISTORY: *
* 07/26/1996 JLB : Created. *
*=============================================================================================*/
void TeamClass::Scan_Limit(void)
{
Assign_Mission_Target(TARGET_NONE);
FootClass * foot = Member;
while (foot != NULL) {
foot->Assign_Target(TARGET_NONE);
foot->IsScanLimited = true;
foot = foot->Member;
}
}
/***********************************************************************************************
* TeamClass::TMission_Formation -- Process team formation change command. *
* *
* This routine will change the team's formation to that specified in the team command *
* parameter. It is presumed that the team will have further movement orders so that the *
* formation can serve some purpose. Merely changing the formation doesn't alter the *
* member's location. The team must be given a movement order before team member *
* repositioning will occur. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the time to delay before further team actions should occur. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/06/1996 JLB : Created. *
*=============================================================================================*/
int TeamClass::TMission_Formation(void)
{
FootClass * member = Member;
TeamMissionClass const * mission = &Class->MissionList[CurrentMission];
Formation = mission->Data.Formation;
int group = ID + 10;
int xdir = 0;
int ydir = 0;
bool evenodd = 1;
HousesType house = (member != NULL) ? member->Owner() : HOUSE_NONE;
/*
** Assign appropriate formation offsets for each of the members
** of this team.
*/
switch (Formation) {
case FORMATION_NONE:
while (member != NULL) {
member->Group = 0xFF;
member->XFormOffset = 0x80000000;
member->YFormOffset = 0x80000000;
member->IsFormationMove = false;
member = member->Member;
}
break;
case FORMATION_TIGHT:
while (member != NULL) {
member->Group = group;
member->XFormOffset = 0;
member->YFormOffset = 0;
member->IsFormationMove = true;
member = member->Member;
}
break;
case FORMATION_LOOSE:
break;
case FORMATION_WEDGE_N:
ydir = -(Total / 2);
xdir = 0;
while (member != NULL) {
member->Group = group;
member->XFormOffset = xdir;
member->YFormOffset = ydir;
member->IsFormationMove = true;
xdir = -xdir;
evenodd ^= 1;
if (!evenodd) {
xdir -= 2;
ydir += 2;
}
member = member->Member;
}
break;
case FORMATION_WEDGE_E:
xdir = (Total / 2);
ydir = 0;
while (member != NULL) {
member->Group = group;
member->XFormOffset = xdir;
member->YFormOffset = ydir;
member->IsFormationMove = true;
ydir = -ydir;
evenodd ^= 1;
if (!evenodd) {
xdir -= 2;
ydir -= 2;
}
member = member->Member;
}
break;
case FORMATION_WEDGE_S:
ydir = (Total / 2);
xdir = 0;
while (member != NULL) {
member->Group = group;
member->XFormOffset = xdir;
member->YFormOffset = ydir;
member->IsFormationMove = true;
xdir = -xdir;
evenodd ^= 1;
if (!evenodd) {
xdir -= 2;
ydir -= 2;
}
member = member->Member;
}
break;
case FORMATION_WEDGE_W:
xdir = -(Total / 2);
ydir = 0;
while (member != NULL) {
member->Group = group;
member->XFormOffset = xdir;
member->YFormOffset = ydir;
member->IsFormationMove = true;
ydir = -ydir;
evenodd ^= 1;
if (!evenodd) {
xdir += 2;
ydir -= 2;
}
member = member->Member;
}
break;
case FORMATION_LINE_NS:
ydir = -(Total/2);
while (member != NULL) {
member->Group = group;
member->XFormOffset = 0;
member->YFormOffset = ydir;
member->IsFormationMove = true;
member = member->Member;
ydir += 2;
}
break;
case FORMATION_LINE_EW:
xdir = -(Total/2);
while (member != NULL) {
member->Group = group;
member->XFormOffset = xdir;
member->YFormOffset = 0;
member->IsFormationMove = true;
member = member->Member;
xdir += 2;
}
break;
}
/*
** Now calculate the group's movement type and speed
*/
if (Formation != FORMATION_NONE && house != HOUSE_NONE) {
TeamFormDataStruct& team_form_data = TeamFormData[house];
team_form_data.TeamSpeed[group] = SPEED_WHEEL;
team_form_data.TeamMaxSpeed[group] = MPH_LIGHT_SPEED;
member = Member;
while (member != NULL) {
RTTIType mytype = member->What_Am_I();
SpeedType memspeed;
MPHType memmax;
bool speedcheck = false;
if (mytype == RTTI_INFANTRY) {
memspeed = SPEED_FOOT;
memmax = ((InfantryClass *)member)->Class->MaxSpeed;
speedcheck = true;
}
if (mytype == RTTI_UNIT) {
memspeed = ((UnitClass *)member)->Class->Speed;
memmax = ((UnitClass *)member)->Class->MaxSpeed;
speedcheck = true;
}
if (mytype == RTTI_VESSEL) {
memspeed = ((VesselClass *)member)->Class->Speed;
memmax = ((VesselClass *)member)->Class->MaxSpeed;
speedcheck = true;
}
if (speedcheck) {
if (memmax < team_form_data.TeamMaxSpeed[group]) {
team_form_data.TeamMaxSpeed[group] = memmax;
team_form_data.TeamSpeed[group] = memspeed;
}
}
member = member->Member;
}
/*
** Now that it's all calculated, assign the movement type and
** speed to every member of the team.
*/
member = Member;
while (member != NULL) {
member->FormationSpeed = team_form_data.TeamSpeed[group];
member->FormationMaxSpeed = team_form_data.TeamMaxSpeed[group];
if (member->What_Am_I() == RTTI_INFANTRY) {
member->FormationSpeed = SPEED_FOOT;
member->FormationMaxSpeed = MPH_SLOW_ISH;
}
member = member->Member;
}
}
// Advance past the formation-setting command.
IsNextMission = true;
return(1);
}
/***********************************************************************************************
* TeamClass::TMission_Attack -- Perform the team attack mission command. *
* *
* This will tell the team to attack the quarry specified in the team command. If the team *
* already has a target, this it is presumed that this target take precidence and it won't *
* be changed. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the delay before the next team logic operation should occur. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/06/1996 JLB : Created. *
*=============================================================================================*/
int TeamClass::TMission_Attack(void)
{
if (!Target_Legal(MissionTarget) && Member != NULL) {
TeamMissionClass const * mission = &Class->MissionList[CurrentMission];
/*
** Pick a team leader that has a weapon. Only in the case of no
** team members having any weapons, will a member without a weapon
** be chosen.
*/
FootClass const * candidate = Fetch_A_Leader();
/*
** Have the team leader pick what the next team target will be.
*/
switch (mission->Data.Quarry) {
case QUARRY_ANYTHING:
Assign_Mission_Target(candidate->Greatest_Threat(THREAT_NORMAL));
break;
case QUARRY_BUILDINGS:
Assign_Mission_Target(candidate->Greatest_Threat(THREAT_BUILDINGS));
break;
case QUARRY_HARVESTERS:
Assign_Mission_Target(candidate->Greatest_Threat(THREAT_TIBERIUM));
break;
case QUARRY_INFANTRY:
Assign_Mission_Target(candidate->Greatest_Threat(THREAT_INFANTRY));
break;
case QUARRY_VEHICLES:
Assign_Mission_Target(candidate->Greatest_Threat(THREAT_VEHICLES));
break;
case QUARRY_FACTORIES:
Assign_Mission_Target(candidate->Greatest_Threat(THREAT_FACTORIES));
break;
case QUARRY_DEFENSE:
Assign_Mission_Target(candidate->Greatest_Threat(THREAT_BASE_DEFENSE));
break;
case QUARRY_THREAT:
Assign_Mission_Target(candidate->Greatest_Threat(THREAT_NORMAL));
break;
case QUARRY_POWER:
Assign_Mission_Target(candidate->Greatest_Threat(THREAT_POWER));
break;
case QUARRY_FAKES:
Assign_Mission_Target(candidate->Greatest_Threat(THREAT_FAKES));
break;
default:
break;
}
if (!Target_Legal(MissionTarget)) IsNextMission = true;
}
Coordinate_Attack();
return(1);
}
/***********************************************************************************************
* TeamClass::TMission_Spy -- Perform the team spy mission. *
* *
* This will give the team a spy mission to the location specified. It is presumed that *
* the location of the team mission actually resides under the building to be spied. If *
* no building exists at the location, then the spy operation is presumed to be a mere *
* move operation. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the delay before the next team logic operation should occur. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/06/1996 JLB : Created. *
*=============================================================================================*/
int TeamClass::TMission_Spy(void)
{
if (Is_Target_Cell(MissionTarget))
{
CELL cell = ::As_Cell(MissionTarget);
CellClass * cellptr = &Map[cell];
#ifdef FIXIT_CSII // checked - ajw 9/28/98
ObjectClass * bldg = cellptr->Cell_Building();
#else
ObjectClass * bldg = cellptr->Cell_Object();
#endif
if (bldg != NULL)
{
Assign_Mission_Target(bldg->As_Target());
Coordinate_Attack();
}
#ifdef FIXIT_CSII // checked - ajw 9/28/98
else
{
FootClass *member = Member;
if(member->What_Am_I() == RTTI_UNIT && *(UnitClass *)member == UNIT_CHRONOTANK)
{
bool finished = true;
while (member)
{
if ( !((UnitClass *)member)->MoebiusCountDown) finished = false;
member = member->Member;
}
if (!finished)
{
Coordinate_Attack();
}
else
{
Assign_Mission_Target(TARGET_NONE);
IsNextMission = true;
}
}
}
#endif
}
else
{
if (!Target_Legal(MissionTarget))
{
Assign_Mission_Target(TARGET_NONE);
IsNextMission = true;
}
else
{
Coordinate_Attack();
}
}
return(1);
}
/***********************************************************************************************
* TeamClass::TMission_Follow -- Perform the "follow friendlies" team command. *
* *
* This will cause the team members to search out and follow the nearest friendly object. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the delay before the next team logic operation should be performed. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/06/1996 JLB : Created. *
*=============================================================================================*/
int TeamClass::TMission_Follow(void)
{
Calc_Center(Zone, ClosestMember);
Target = Zone;
Coordinate_Move();
return(1);
}
/***********************************************************************************************
* TeamClass::TMission_Loop -- Causes the team mission processor to jump to new location. *
* *
* This is equivalent to a jump or goto command. It will alter the team command processing *
* such that it will continue processing at the command number specified. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the delay before the next team logic operation should be performed. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/06/1996 JLB : Created. *
*=============================================================================================*/
int TeamClass::TMission_Loop(void)
{
TeamMissionClass const * mission = &Class->MissionList[CurrentMission];
CurrentMission = mission->Data.Value-1;
IsNextMission = true;
return(1);
}
/***********************************************************************************************
* TeamClass::TMission_Invulnerable -- Makes the entire team invulnerable for a period of time *
* *
* This is a team mission that simulates the Iron Curtain device. It will make all team *
* members invlunerable for a temporary period of time. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the time delay before the next team logic operation should occur. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/06/1996 JLB : Created. *
*=============================================================================================*/
int TeamClass::TMission_Invulnerable(void)
{
FootClass * foot = Member;
while (foot != NULL) {
foot->IronCurtainCountDown = Rule.IronCurtainDuration * TICKS_PER_MINUTE;
foot->Mark(MARK_CHANGE);
foot = foot->Member;
}
IsNextMission = true;
return(1);
}
/***********************************************************************************************
* TeamClass::TMission_Set_Global -- Performs a set global flag operation. *
* *
* This routine is used by the team to set a global variable but otherwise perform no *
* visible effect on the team. By using this routine, sophisticated trigger dependencies *
* can be implemented. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the delay before the next team logic operation should occur. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/06/1996 JLB : Created. *
*=============================================================================================*/
int TeamClass::TMission_Set_Global(void)
{
TeamMissionClass const * mission = &Class->MissionList[CurrentMission];
Scen.Set_Global_To(mission->Data.Value, true);
IsNextMission = true;
return(1);
}
/***********************************************************************************************
* TeamClass::TMision_Patrol -- Handles patrolling from one location to another. *
* *
* A patrolling team will move to the designated waypoint, but along the way it will *
* periodically scan for nearby enemies. If an enemy is found, the patrol mission turns *
* into an attack mission until the target is destroyed -- after which it resumes its *
* patrol duties. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the delay before the next call to this routine is needed. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/12/1996 JLB : Created. *
*=============================================================================================*/
int TeamClass::TMission_Patrol(void)
{
/*
** Reassign the movement destination if the target has been prematurely
** cleared (probably because the object has been destroyed).
*/
if (!Target_Legal(Target)) {
TeamMissionClass const * mission = &Class->MissionList[CurrentMission];
if ((unsigned)mission->Data.Value < WAYPT_COUNT) {
Assign_Mission_Target(::As_Target(Scen.Waypoint[mission->Data.Value]));
}
}
/*
** Every so often, scan for a nearby enemy.
*/
if (Frame % (Rule.PatrolTime * TICKS_PER_MINUTE) == 0) {
FootClass * leader = Fetch_A_Leader();
if (leader != NULL) {
TARGET target = leader->Greatest_Threat(THREAT_NORMAL|THREAT_RANGE);
if (Target_Legal(target)) {
Assign_Mission_Target(target);
} else {
Assign_Mission_Target(TARGET_NONE);
}
}
}
/*
** If the mission target looks like it should be attacked, then do so, otherwise
** treat it as a movement destination.
*/
if (Is_Target_Object(Target)) {
Coordinate_Attack();
} else {
Coordinate_Move();
}
return(1);
}
int TeamClass::TMission_Deploy(void)
{
assert(IsActive);
assert(Teams.ID(this) == ID);
FootClass * unit = Member;
bool finished = true;
while (unit != NULL) {
Coordinate_Conscript(unit);
if (_Is_It_Playing(unit)) {
if (unit->What_Am_I() == RTTI_UNIT && *(UnitClass *)unit == UNIT_MCV) {
if (unit->Mission != MISSION_UNLOAD) {
unit->Assign_Destination(TARGET_NONE);
unit->Assign_Target(TARGET_NONE);
unit->Assign_Mission(MISSION_UNLOAD);
finished = false;
}
}
if (unit->What_Am_I() == RTTI_UNIT && *(UnitClass *)unit == UNIT_MINELAYER && unit->Ammo != 0) {
/*
** The check for a building is located here because the mine layer may have
** already unloaded the mine but is still in the process of retracting
** the mine layer. During this time, it should not be considered to have
** finished its unload mission.
*/
if (!Map[unit->Center_Coord()].Cell_Building() && unit->Mission != MISSION_UNLOAD) {
unit->Assign_Destination(TARGET_NONE);
unit->Assign_Target(TARGET_NONE);
unit->Assign_Mission(MISSION_UNLOAD);
finished = false;
}
}
}
unit = unit->Member;
}
if (finished) {
IsNextMission = true;
}
return(1);
}
/***********************************************************************************************
* TeamClass::Fetch_A_Leader -- Looks for a suitable leader member of the team. *
* *
* This will scan through the team members looking for one that is suitable as a leader *
* type. A team can sometimes contain limboed or unarmed members. These members are not *
* suitable for leadership roles. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with a suitable leader type unit. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/27/1996 JLB : Created. *
*=============================================================================================*/
FootClass * TeamClass::Fetch_A_Leader(void) const
{
FootClass * leader = Member;
/*
** Scan through the team members trying to find one that is an active member and
** is equipped with a weapon.
*/
while (leader != NULL) {
if (_Is_It_Playing(leader) && leader->Is_Weapon_Equipped()) break;
leader = leader->Member;
}
/*
** If no suitable leader was found, then just return with the first conveniently
** accessable team member. This presumes that some member is better than no member
** at all.
*/
if (leader == NULL) {
leader = Member;
}
return(leader);
}
Reference in New Issue View Git Blame Copy Permalink