CodeMirror/CnC_Remastered_Collection
1
0
Fork 0
mirror of https://github.com/electronicarts/CnC_Remastered_Collection synced 2024-04-27 00:43:00 +12:00
Code Issues Releases Wiki Activity
CnC_Remastered_Collection/REDALERT/AIRCRAFT.CPP
PG-SteveT ae72fce5dd August 6th Patch Update 
Accumulated DLL source code changes since June 22nd patch
2020-08-06 09:44:54 -07:00

4451 lines
182 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/AIRCRAFT.CPP 1 3/03/97 10:24a 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 : AIRCRAFT.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : July 22, 1994 *
* *
* Last Update : November 2, 1996 [JLB] *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* AircraftClass::AI -- Processes the normal non-graphic AI for the aircraft. *
* AircraftClass::Active_Click_With -- Handles clicking over specified cell. *
* AircraftClass::Active_Click_With -- Handles clicking over specified object. *
* AircraftClass::AircraftClass -- The constructor for aircraft objects. *
* AircraftClass::Can_Enter_Cell -- Determines if the aircraft can land at this location. *
* AircraftClass::Can_Fire -- Checks to see if the aircraft can fire. *
* AircraftClass::Cell_Seems_Ok -- Checks to see if a cell is good to enter. *
* AircraftClass::Desired_Load_Dir -- Determines where passengers should line up. *
* AircraftClass::Draw_It -- Renders an aircraft object at the location specified. *
* AircraftClass::Draw_Rotors -- Draw rotor blades on the aircraft. *
* AircraftClass::Edge_Of_World_AI -- Detect if aircraft has exited the map. *
* AircraftClass::Enter_Idle_Mode -- Gives the aircraft an appropriate mission. *
* AircraftClass::Exit_Object -- Unloads passenger from aircraft. *
* AircraftClass::Fire_At -- Handles firing a projectile from an aircraft. *
* AircraftClass::Fire_Direction -- Determines the direction of fire. *
* AircraftClass::Good_Fire_Location -- Searches for and finds a good spot to fire from. *
* AircraftClass::Good_LZ -- Locates a good spot ot land. *
* AircraftClass::In_Which_Layer -- Calculates the display layer of the aircraft. *
* AircraftClass::Init -- Initialize the aircraft system to an empty state. *
* AircraftClass::Is_LZ_Clear -- Determines if landing zone is free for landing. *
* AircraftClass::Landing_Takeoff_AI -- Handle aircraft take off and landing processing. *
* AircraftClass::Look -- Aircraft will look if they are on the ground always. *
* AircraftClass::Mission_Attack -- Handles the attack mission for aircraft. *
* AircraftClass::Mission_Enter -- Control aircraft to fly to the helipad or repair center. *
* AircraftClass::Mission_Guard -- Handles aircraft in guard mode. *
* AircraftClass::Mission_Guard_Area -- Handles the aircraft guard area logic. *
* AircraftClass::Mission_Hunt -- Maintains hunt AI for the aircraft. *
* AircraftClass::Mission_Move -- Handles movement mission. *
* AircraftClass::Mission_Retreat -- Handles the aircraft logic for leaving the battlefield. *
* AircraftClass::Mission_Unload -- Handles unloading cargo. *
* AircraftClass::Movement_AI -- Handles aircraft physical movement logic. *
* AircraftClass::New_LZ -- Find a good landing zone. *
* AircraftClass::Overlap_List -- Returns with list of cells the aircraft overlaps. *
* AircraftClass::Paradrop_Cargo -- Drop a passenger by parachute. *
* AircraftClass::Per_Cell_Process -- Handle the aircraft per cell process. *
* AircraftClass::Pip_Count -- Returns the number of "objects" in aircraft. *
* AircraftClass::Player_Assign_Mission -- Handles player input to assign a mission. *
* AircraftClass::Pose_Dir -- Fetches the natural landing facing. *
* AircraftClass::Process_Fly_To -- Handles state machine for flying to destination. *
* AircraftClass::Process_Landing -- Landing process state machine handler. *
* AircraftClass::Process_Take_Off -- State machine support for taking off. *
* AircraftClass::Read_INI -- Reads aircraft object data from an INI file. *
* AircraftClass::Receive_Message -- Handles receipt of radio messages. *
* AircraftClass::Response_Attack -- Gives audio response to attack order. *
* AircraftClass::Response_Move -- Gives audio response to move request. *
* AircraftClass::Response_Select -- Gives audio response when selected. *
* AircraftClass::Rotation_AI -- Handle aircraft body and flight rotation. *
* AircraftClass::Scatter -- Causes the aircraft to move away a bit. *
* AircraftClass::Set_Speed -- Sets the speed for the aircraft. *
* AircraftClass::Shape_Number -- Fetch the shape number to use for the aircraft. *
* AircraftClass::Sort_Y -- Figures the sorting coordinate. *
* AircraftClass::Take_Damage -- Applies damage to the aircraft. *
* AircraftClass::Unlimbo -- Removes an aircraft from the limbo state. *
* AircraftClass::What_Action -- Determines what action to perform. *
* AircraftClass::What_Action -- Determines what action to perform. *
* AircraftClass::operator delete -- Deletes the aircraft object. *
* AircraftClass::operator new -- Allocates a new aircraft object from the pool *
* AircraftClass::~AircraftClass -- Destructor for aircraft object. *
* _Counts_As_Civ_Evac -- Is the specified object a candidate for civilian evac logic? *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
/***********************************************************************************************
* _Counts_As_Civ_Evac -- Is the specified object a candidate for civilian evac logic? *
* *
* Examines the specified object to see if it qualifies to be a civilian evacuation. This *
* can only occur if it is a civilian (or Tanya) and the special evacuation flag has been *
* set in the scenario control structure. *
* *
* INPUT: candidate -- Candidate object to examine for civilian evacuation legality. *
* *
* OUTPUT: bool; Is the specified object considered a civilian that must be auto-evacuated? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/24/1996 JLB : Created. *
*=============================================================================================*/
static bool _Counts_As_Civ_Evac(ObjectClass const * candidate)
{
/*
** If the candidate pointer is missing, then return with failure code.
*/
if (candidate == NULL) return(false);
/*
** Only infantry objects can be considered for civilian evacuation action.
*/
if (candidate->What_Am_I() != RTTI_INFANTRY) return(false);
/*
** Working infantry object pointer.
*/
InfantryClass const * inf = (InfantryClass const *)candidate;
/*
** Certain infantry types will always be considered a civilian evacuation candidate. These
** include the special one-time infantry that appear in some missions.
*/
if (*inf == INFANTRY_EINSTEIN || *inf == INFANTRY_GENERAL || *inf == INFANTRY_DELPHI || *inf == INFANTRY_CHAN) return(true);
/*
** Consider Tanya to be part of the civilian evacuation logic if the scenario is
** specially flagged for this.
*/
if (Scen.IsTanyaEvac && *inf == INFANTRY_TANYA) return(true);
/*
** If the infantry is not a civilian, then it isn't allowed to be a civilian evacuation.
*/
if (!inf->Class->IsCivilian) return(false);
/*
** Technicians look like civilians, but are not considered a legal evacuation candidate.
*/
if (inf->IsTechnician) return(false);
/*
** All tests pass, so return the success of the infantry as a civilian evacuation candidate.
*/
return(true);
}
/***********************************************************************************************
* AircraftClass::operator new -- Allocates a new aircraft object from the pool *
* *
* This routine will allocate an aircraft object from the free aircraft object pool. If *
* there are no free object available, then this routine will fail (return NULL). *
* *
* INPUT: none *
* *
* OUTPUT: Returns with a pointer to the allocate aircraft object or NULL if none were *
* available. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/26/1994 JLB : Created. *
*=============================================================================================*/
void * AircraftClass::operator new(size_t)
{
void * ptr = Aircraft.Allocate();
if (ptr) {
((AircraftClass *)ptr)->Set_Active();
}
return(ptr);
}
/***********************************************************************************************
* AircraftClass::operator delete -- Deletes the aircraft object. *
* *
* This routine will return the aircraft object back to the free aircraft object pool. *
* *
* INPUT: ptr -- Pointer to the aircraft object to delete. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/26/1994 JLB : Created. *
*=============================================================================================*/
void AircraftClass::operator delete(void * ptr)
{
if (ptr) {
((AircraftClass *)ptr)->IsActive = false;
}
Aircraft.Free((AircraftClass *)ptr);
}
/***********************************************************************************************
* AircraftClass::AircraftClass -- The constructor for aircraft objects. *
* *
* This routine is the constructor for aircraft objects. An aircraft object can be *
* created and possibly placed into the game system by this routine. *
* *
* INPUT: classid -- The type of aircraft to create. *
* *
* house -- The owner of this aircraft. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/26/1994 JLB : Created. *
*=============================================================================================*/
AircraftClass::AircraftClass(AircraftType classid, HousesType house) :
FootClass(RTTI_AIRCRAFT, Aircraft.ID(this), house),
Class(AircraftTypes.Ptr((int)classid)),
SecondaryFacing(PrimaryFacing),
Passenger(false),
IsLanding(false),
IsTakingOff(false),
IsHovering(false),
Jitter(0),
SightTimer(0),
AttacksRemaining(1)
{
/*
** For two shooters, clear out the second shot flag -- it will be set the first time
** the object fires. For non two shooters, set the flag since it will never be cleared
** and the second shot flag tells the system that normal rearm times apply -- this is
** what is desired for non two shooters.
*/
IsSecondShot = !Class->Is_Two_Shooter();
House->Tracking_Add(this);
Ammo = Class->MaxAmmo;
Height = FLIGHT_LEVEL;
Strength = Class->MaxStrength;
NavCom = TARGET_NONE;
/*
** Keep count of the number of units created. Dont track cargo planes as they are created
** automatically, not bought.
*/
// if (/*classid != AIRCRAFT_CARGO && */ Session.Type == GAME_INTERNET) {
// House->AircraftTotals->Increment_Unit_Total((int)classid);
// }
}
/***********************************************************************************************
* AircraftClass::Unlimbo -- Removes an aircraft from the limbo state. *
* *
* This routine is used to transition the aircraft from the limbo to the non limbo state. *
* It occurs when the aircraft is placed on the map for whatever reason. When it is *
* unlimboed, only then will normal game processing recognize it. *
* *
* INPUT: coord -- The coordinate that the aircraft should appear at. *
* *
* dir -- The direction it should start facing. *
* *
* strength (optional) -- sets initial strength *
* *
* mission (optional) -- sets initial mission *
* *
* OUTPUT: bool; Was the aircraft unlimboed successfully? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/26/1994 JLB : Created. *
*=============================================================================================*/
bool AircraftClass::Unlimbo(COORDINATE coord, DirType dir)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (FootClass::Unlimbo(coord, dir)) {
if (*this == AIRCRAFT_BADGER || (Class->PrimaryWeapon != NULL && Class->PrimaryWeapon->IsCamera)) {
IsALoaner = true;
}
/*
** Ensure that the owning house knows about the
** new object.
*/
House->AScan |= (1L << Class->Type);
House->ActiveAScan |= (1L << Class->Type);
/*
** Hack it so that aircraft that are both passenger and cargo carrying
** will carry passengers at the expense of ammo.
*/
if (Is_Something_Attached()) {
Ammo = 0;
Passenger = true;
}
/*
** Forces the body of the helicopter to face the correct direction.
*/
SecondaryFacing = dir;
/*
** Start rotor animation.
*/
if (!Class->IsFixedWing) {
Set_Rate(1);
Set_Stage(0);
}
/*
** When starting at flight level, then give it speed. When landed
** then it must be stationary.
*/
if (Height == FLIGHT_LEVEL) {
Set_Speed(0xFF);
} else {
Set_Speed(0);
}
return(true);
}
return(false);
}
/***********************************************************************************************
* AircraftClass::Shape_Number -- Fetch the shape number to use for the aircraft. *
* *
* This will determine what shape number to use for the aircraft in its current state. *
* The shape number can be used for drawing or determine shape rectangle size. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the shape number to use for the aircraft body. *
* *
* WARNINGS: Some aircraft, particularly helicopters, require other shapes attached to it. *
* *
* HISTORY: *
* 07/26/1996 JLB : Created. *
*=============================================================================================*/
int AircraftClass::Shape_Number(void) const
{
int shapenum = 0;
switch (Class->Rotation) {
case 32:
shapenum = UnitClass::BodyShape[Dir_To_32(SecondaryFacing)];
break;
case 16:
shapenum = UnitClass::BodyShape[Dir_To_16(SecondaryFacing)*2]/2;
break;
case 8:
shapenum = UnitClass::BodyShape[Dir_To_8(SecondaryFacing)*4]/4;
break;
default:
break;
}
/*
** If there is a door on this aircraft (Chinook), then adjust the
** shape number to match the door open state.
*/
if (!Is_Door_Closed()) {
shapenum = Class->Rotation + Door_Stage();
}
return(shapenum);
}
/***********************************************************************************************
* AircraftClass::Draw_It -- Renders an aircraft object at the location specified. *
* *
* This routine is used to display the aircraft object at the coordinates specified. *
* The tactical map display uses this routine for all aircraft rendering. *
* *
* INPUT: x,y -- The coordinates to render the aircraft at. *
* *
* window -- The window that the coordinates are based upon. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/26/1994 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Draw_It(int x, int y, WindowNumberType window) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
/*
** Verify the legality of the unit class.
*/
void const * shapefile = Get_Image_Data();
if (!shapefile) return;
int shapenum = Shape_Number();
/*
** Certain aircraft use algorithmic rotation for some stages. Set the
** rotation value accordingly. A rotation of DIR_N means no rotation at all.
*/
DirType rotation = DIR_N;
if (Class->Rotation == 16) {
rotation = DirType(Rotation16[SecondaryFacing]);
}
#ifdef TOFIX
/*
** The orca attack helicopter uses a special shape set when it is travelling
** forward above a certain speed.
*/
if (*this == AIRCRAFT_HIND && Get_Speed() >= MPH_MEDIUM_FAST) {
shapenum += Class->Rotation;
}
#endif
/*
** Helicopters that are flying have a "bobbing" effect.
*/
int jitter = 0;
if (Height == FLIGHT_LEVEL && Get_Speed() < 3) {
static int _jitter[] = {0,0,0,0,1,1,1,0,0,0,0,0,-1,-1,-1,0};
jitter = _jitter[::Frame % 16];
}
// Virtual window needs to draw the body first so it's considered the primary object and the shadow is a sub-object
if (window == WINDOW_VIRTUAL) {
/*
** Draw the root body of the unit.
*/
Techno_Draw_Object(shapefile, shapenum, x, y+jitter, window, rotation);
/*
** Special manual shadow draw code.
*/
if (Visual_Character() <= VISUAL_DARKEN) {
CC_Draw_Shape(this, shapefile, shapenum, x+1, y+2, window, SHAPE_PREDATOR|SHAPE_CENTER|SHAPE_WIN_REL|SHAPE_FADING, DisplayClass::FadingShade, NULL);
}
} else {
/*
** Special manual shadow draw code.
*/
if (Visual_Character() <= VISUAL_DARKEN) {
CC_Draw_Shape(this, shapefile, shapenum, x+1, y+2, window, SHAPE_PREDATOR|SHAPE_CENTER|SHAPE_WIN_REL|SHAPE_FADING, DisplayClass::FadingShade, NULL);
}
/*
** Draw the root body of the unit.
*/
Techno_Draw_Object(shapefile, shapenum, x, y+jitter, window, rotation);
}
/*
** If this aircraft is equipped with rotor blades, then draw them at this time.
*/
if (Class->IsRotorEquipped) {
Draw_Rotors(x, y+jitter, window);
}
/*
** This draws any overlay graphics on the aircraft.
*/
FootClass::Draw_It(x, y-Lepton_To_Pixel(Height), window);
}
/***********************************************************************************************
* AircraftClass::Draw_Rotors -- Draw rotor blades on the aircraft. *
* *
* This routine will draw rotor blades on the aircraft. It is presumed that the aircraft *
* has already been drawn at the X and Y pixel coordinates specified. *
* *
* INPUT: x,y -- The X and Y pixel coordinates to draw the rotor blades. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/26/1996 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Draw_Rotors(int x, int y, WindowNumberType window) const
{
ShapeFlags_Type flags = SHAPE_CENTER|SHAPE_WIN_REL;
int shapenum;
/*
** The rotor shape number depends on whether the helicopter is idling
** or not. A landed helicopter uses slow moving "idling" blades.
*/
if (Height == 0) {
shapenum = (Fetch_Stage()%8)+4;
flags = flags | SHAPE_GHOST;
} else {
shapenum = Fetch_Stage()%4;
flags = flags | SHAPE_FADING|SHAPE_PREDATOR;
}
if (*this == AIRCRAFT_TRANSPORT) {
int _stretch[FACING_COUNT] = {8, 9, 10, 9, 8, 9, 10, 9};
/*
** Dual rotors offset along flight axis.
*/
short xx = x;
short yy = y-Lepton_To_Pixel(Height);
FacingType face = Dir_Facing(SecondaryFacing);
Move_Point(xx, yy, SecondaryFacing.Current(), _stretch[face]);
// Add 'this' parameter to call new shape draw intercept. ST - 5/22/2019
CC_Draw_Shape(this, "RROTOR", AircraftTypeClass::RRotorData, shapenum, xx, yy-2, window, flags, NULL, DisplayClass::UnitShadow);
Move_Point(xx, yy, SecondaryFacing.Current()+DIR_S, _stretch[face]*2);
// Add 'this' parameter to call new shape draw intercept. ST - 5/22/2019
CC_Draw_Shape(this, "LROTOR", AircraftTypeClass::LRotorData, shapenum, xx, yy-2, window, flags, NULL, DisplayClass::UnitShadow);
} else {
/*
** Single rotor centered about shape.
*/
// Add 'this' parameter to call new shape draw intercept. ST - 5/22/2019
CC_Draw_Shape(this, "RROTOR", AircraftTypeClass::RRotorData, shapenum, x, ((y-Lepton_To_Pixel(Height))-2), window, flags, NULL, DisplayClass::UnitShadow);
}
}
/***********************************************************************************************
* AircraftClass::Read_INI -- Reads aircraft object data from an INI file. *
* *
* This routine is used to read the aircraft object data from the INI file buffer *
* specified. This is used by the scenario loader code to interpret the INI file and *
* create the specified objects therein. *
* *
* INPUT: buffer -- Pointer to the INI buffer. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/26/1994 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Read_INI(CCINIClass & ini)
{
AircraftClass * air; // Working unit pointer.
HousesType inhouse; // Unit house.
AircraftType classid; // Unit class.
char buf[128];
int counter = ini.Entry_Count(INI_Name());
for (int index = 0; index < counter; index++) {
char const * entry = ini.Get_Entry(INI_Name(), index);
ini.Get_String(INI_Name(), entry, NULL, buf, sizeof(buf)-1);
inhouse = HouseTypeClass::From_Name(strtok(buf, ","));
if (inhouse != HOUSE_NONE) {
classid = AircraftTypeClass::From_Name(strtok(NULL, ","));
if (classid != AIRCRAFT_NONE) {
if (HouseClass::As_Pointer(inhouse) != NULL) {
air = new AircraftClass(classid, inhouse);
if (air) {
COORDINATE coord;
int strength;
DirType dir;
/*
** Read the raw data.
*/
char * token = strtok(NULL, ",");
if (token) {
strength = atoi(token);
} else {
strength = 0;
}
token = strtok(NULL, ",");
if (token) {
coord = Cell_Coord((CELL)atoi(token));
} else {
coord = 0xFFFFFFFFL;
}
token = strtok(NULL, ",");
if (token) {
dir = (DirType)atoi(token);
} else {
dir = DIR_N;
}
if (!Map.In_Radar(Coord_Cell(coord))) {
delete air;
} else {
air->Strength = (int)air->Class->MaxStrength * fixed(strength, 256); // Cast this to (int). ST - 5/8/19
if (air->Unlimbo(coord, dir)) {
air->Assign_Mission(AircraftClass::Mission_From_Name(strtok(NULL, ",\n\r")));
} else {
delete air;
}
}
}
}
}
}
}
}
/***********************************************************************************************
* AircraftClass::Mission_Hunt -- Maintains hunt AI for the aircraft. *
* *
* Hunt AI consists of finding a target and attacking it. If there is no target assigned *
* and this unit doesn't automatically hunt for more targets, then it will change *
* mission to a more passive (land and await further orders) type. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the number of ticks before calling this routine again. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/26/1994 JLB : Created. *
*=============================================================================================*/
int AircraftClass::Mission_Hunt(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (Class->IsFixedWing) {
if (TarCom != NavCom) {
Assign_Destination(TarCom);
}
enum {
LOOK_FOR_TARGET,
TAKE_OFF,
FLY_TO_TARGET,
DROP_BOMBS,
REGROUP
};
switch (Status) {
/*
** Acquiring target stage.
*/
case LOOK_FOR_TARGET:
if (Target_Legal(TarCom)) {
Status = TAKE_OFF;
return(1);
} else {
if (!Team.Is_Valid()) {
if (Session.Type != GAME_NORMAL) {
Assign_Target(Greatest_Threat(THREAT_TIBERIUM));
}
if (!Target_Legal(TarCom)) {
Assign_Target(Greatest_Threat(THREAT_NORMAL));
}
/*
** If there is no target, then this aircraft should just do its normal thing.
*/
if (!Target_Legal(TarCom) && !Team.Is_Valid()) {
Enter_Idle_Mode();
}
}
}
break;
/*
** Make the aircraft take off from the airstrip.
*/
case TAKE_OFF:
/*
** If the aircraft is high enough to begin its mission, then do so.
*/
if (Process_Take_Off()) {
IsTakingOff = false;
Set_Speed(0xFF);
/*
** After takeoff is complete, break radio contact.
*/
if (In_Radio_Contact()/*KO && Map[Coord].Cell_Building() == Contact_With_Whom()*/) {
Transmit_Message(RADIO_OVER_OUT);
}
Status = FLY_TO_TARGET;
}
return(1);
/*
** Homing in on target stage.
*/
case FLY_TO_TARGET:
switch (Can_Fire(TarCom, 0)) {
case FIRE_FACING:
/*
** Catch the case where it is tightly circling the target. In that
** case, increase the delay so that it has a chance to fly away and
** break the circle cycle.
*/
if (In_Range(TarCom, 0) || Passenger) {
return(TICKS_PER_SECOND * 2);
}
if (!PrimaryFacing.Is_Rotating() && Target_Legal(TarCom)) {
PrimaryFacing.Set_Desired(Direction(TarCom));
}
break;
case FIRE_AMMO:
Status = REGROUP;
break;
case FIRE_CANT:
case FIRE_ILLEGAL:
if (Mission == MISSION_ATTACK) {
Status = REGROUP;
} else {
Status = LOOK_FOR_TARGET;
}
break;
case FIRE_OK:
Status = DROP_BOMBS;
return(1);
default:
if (!PrimaryFacing.Is_Rotating() && Target_Legal(TarCom)) {
PrimaryFacing.Set_Desired(Direction(TarCom));
}
break;
}
return(TICKS_PER_SECOND/2);
/*
** Dropping a stream of bombs phase.
*/
case DROP_BOMBS:
TARGET targ;
switch (Can_Fire(TarCom, 0)) {
case FIRE_OK:
targ = ::As_Target(Coord_Move(Center_Coord(), SecondaryFacing, Weapon_Range(0)-0x0200));
if (Class->PrimaryWeapon != NULL) {
if (Class->PrimaryWeapon->IsCamera) {
Status = REGROUP;
} else {
Map[::As_Cell(TarCom)].Incoming(Coord, true);
}
/*
** Force the target to be the actual target if this aircraft is
** equipped with homing projectile.
*/
if (Class->PrimaryWeapon->Bullet != NULL && Class->PrimaryWeapon->Bullet->ROT > 0) {
targ = TarCom;
}
}
Fire_At(targ, 0);
if (Class->Is_Two_Shooter()) {
Fire_At(targ, 0);
}
return(Arm);
case FIRE_RANGE:
case FIRE_FACING:
Status = FLY_TO_TARGET;
return(TICKS_PER_SECOND*4);
case FIRE_ILLEGAL:
if (Mission == MISSION_ATTACK) {
Status = REGROUP;
} else {
Status = LOOK_FOR_TARGET;
}
break;
case FIRE_CANT:
Status = REGROUP;
break;
case FIRE_AMMO:
AttacksRemaining--;
Status = REGROUP;
break;
default:
break;
}
return(1);
/*
** Pull away to regroup for possibly another attack or a retreat.
*/
case REGROUP:
if (Ammo == 0) {
AttacksRemaining = 0;
if (Team.Is_Valid()) Team->Remove(this);
Enter_Idle_Mode();
}
if (Mission == MISSION_ATTACK || (Class->PrimaryWeapon != NULL && Class->PrimaryWeapon->IsCamera) || (!AttacksRemaining && !Is_Something_Attached())) {
if (IsALoaner) {
if (Team) Team->Remove(this);
Assign_Mission(MISSION_RETREAT);
Commence();
} else {
if (!Team.Is_Valid()) Enter_Idle_Mode();
}
Commence();
} else {
Status = LOOK_FOR_TARGET;
}
break;
default:
break;
}
} else {
if (!Ammo) {
if (Team) Team->Remove(this);
Enter_Idle_Mode();
} else {
if (!Target_Legal(TarCom)) {
if (Session.Type != GAME_NORMAL) {
Assign_Target(Greatest_Threat(THREAT_TIBERIUM));
}
if (!Target_Legal(TarCom)) {
Assign_Target(Greatest_Threat(THREAT_NORMAL));
}
if (!Target_Legal(TarCom)) {
Enter_Idle_Mode();
return(1);
}
}
Assign_Mission(MISSION_ATTACK);
return(1);
}
}
return(MissionControl[Mission].Normal_Delay() + Random_Pick(0, 2));
}
/***********************************************************************************************
* AircraftClass::AI -- Processes the normal non-graphic AI for the aircraft. *
* *
* This handles the non-graphic AI processing for the aircraft. This usually entails *
* maintenance and other AI functions. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/26/1994 JLB : Created. *
*=============================================================================================*/
void AircraftClass::AI(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
/*
** A Mission change can always occur if the aircraft is landed or flying.
*/
if (!IsLanding && !IsTakingOff) {
Commence();
}
/*
** Perform any base class AI processing. If during this process, the aircraft was
** destroyed, then detect this and bail from this AI routine early.
*/
FootClass::AI();
if (!IsActive) {
return;
}
/*
** A Mission change can always occur if the aircraft is landed or flying.
*/
if (!IsLanding && !IsTakingOff) {
Commence();
}
/*
** Handle any body rotation at this time. Body rotation can occur even if the
** flying object is not actually moving.
*/
Rotation_AI();
/*
** Handle any aircraft movement at this time.
*/
Movement_AI();
/*
** Any aircraft that is not in the ground layer must be redrawn. This is a
** performance hit, but there is no other choice. The cells under an aircraft
** do not know if there is an aircraft above it. Thus, it cannot flag the
** aircraft to redraw. As a consequence, all aircraft must redraw.
*/
if (In_Which_Layer() != LAYER_GROUND) {
Mark();
}
/*
** Perform sighting every so often as controlled by the sight timer.
*/
//if (IsOwnedByPlayer && Class->SightRange && SightTimer == 0) { // Changed to facilitate client/server multiplayer. ST - 8/2/2019 2:29PM
if (House->IsHuman && Class->SightRange && SightTimer == 0) {
Look();
SightTimer = TICKS_PER_SECOND;
}
/*
** Handle landing and taking off logic. Helicopters are prime users of this technique. The
** aircraft will either gain or lose altitude as appropriate. As the aircraft transitions
** between flying level and ground level, it will be moved into the appropriate render
** layer.
*/
if (Landing_Takeoff_AI()) {
return;
}
/*
** Always flag the map draw process to occur if there is an aircraft in the view.
** This ensures that it will be rendered even if there is nothing else that flagged
** the map to be redrawn.
*/
if (Map.In_View(Coord_Cell(Coord))) {
Map.Flag_To_Redraw(false);
Map.DisplayClass::IsToRedraw = true;
}
/*
** When aircraft leave the edge of the map, they might get destroyed. This occurs if the
** aircraft is a non-player produced unit and it has completed its mission. A transport
** helicopter that has already delivered reinforcements is a good example of this.
*/
if (Edge_Of_World_AI()) {
return;
}
}
/***********************************************************************************************
* AircraftClass::Overlap_List -- Returns with list of cells the aircraft overlaps. *
* *
* When aircraft are flying, they can overlap quite a number of cells. These cells can *
* be determined from the coordinate where the aircraft is centered and the size of the *
* aircraft's shape. Landed aircraft are a special case and are usually much smaller *
* than when flying. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with a pointer to a cell offset list that specifies all cells that *
* the aircraft overlaps given the aircraft's current state. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/26/1994 JLB : Created. *
*=============================================================================================*/
short const * AircraftClass::Overlap_List(bool redraw) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
static short const _list[] = {
-(MAP_CELL_W-1), -MAP_CELL_W, -(MAP_CELL_W+1),
-1, 0, 1,
(MAP_CELL_W-1), MAP_CELL_W, (MAP_CELL_W+1),
-((MAP_CELL_W*2)-1), -(MAP_CELL_W*2), -((MAP_CELL_W*2)+1),
-((MAP_CELL_W*3)-1), -(MAP_CELL_W*3), -((MAP_CELL_W*3)+1),
REFRESH_EOL
};
static short const _listbadger[] = {
-(MAP_CELL_W-2), -(MAP_CELL_W-1), -MAP_CELL_W, -(MAP_CELL_W+1), -(MAP_CELL_W+2),
-2, -1, 0, 1, 2,
(MAP_CELL_W-2), (MAP_CELL_W-1), MAP_CELL_W, (MAP_CELL_W+1), (MAP_CELL_W+2),
-((MAP_CELL_W*2)-2), -((MAP_CELL_W*2)-1), -(MAP_CELL_W*2), -((MAP_CELL_W*2)+1), -((MAP_CELL_W*2)+2),
-((MAP_CELL_W*3)-2), -((MAP_CELL_W*3)-1), -(MAP_CELL_W*3), -((MAP_CELL_W*3)+1), -((MAP_CELL_W*3)+2),
REFRESH_EOL
};
if (redraw || Height != 0) {
#ifdef PARTIAL
Rect rect;
if (!IsSelected && Class->DimensionData != NULL && Class->IsFixedWing) {
int shapenum = min(Shape_Number(), Get_Build_Frame_Count(Class->Get_Image_Data())-1);
if (!Class->DimensionData[shapenum].Is_Valid()) {
Class->DimensionData[shapenum] = Shape_Dimensions(Class->Get_Image_Data(), shapenum);
}
rect = Class->DimensionData[shapenum];
/*
** Increase the rectangle for the aircraft since the aircraft could
** have its shape algorithmically rotated.
*/
rect.X -= 5;
rect.Y -= 5;
rect.Width += 10;
rect.Height += 10;
Rect hrect = rect;
hrect.Y -= Lepton_To_Pixel(Height);
return(Coord_Spillage_List(Coord, Union(rect, hrect), true));
}
#endif
if (*this == AIRCRAFT_BADGER) {
return(_listbadger);
} else {
return(_list);
}
}
return(Class->Overlap_List());
}
/***********************************************************************************************
* AircraftClass::Init -- Initialize the aircraft system to an empty state. *
* *
* This routine is used to clear out the aircraft allocation system. It is called in *
* preparation for a scenario load or save game load. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/24/1994 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Init(void)
{
Aircraft.Free_All();
}
/***********************************************************************************************
* AircraftClass::Mission_Unload -- Handles unloading cargo. *
* *
* This function is used to handle finding, heading toward, landing, and unloading the *
* cargo from the aircraft. Once unloading of cargo has occurred, then the aircraft follows *
* a different mission. *
* *
* INPUT: none *
* *
* OUTPUT: Returns the number of game ticks to delay before calling this function again. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/31/94 JLB : Created. *
*=============================================================================================*/
int AircraftClass::Mission_Unload(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (Class->IsFixedWing) {
Assign_Target(NavCom);
return(Mission_Hunt());
} else {
enum {
SEARCH_FOR_LZ,
FLY_TO_LZ,
LAND_ON_LZ,
UNLOAD_PASSENGERS,
TAKE_OFF
};
switch (Status) {
/*
** Search for an appropriate destination spot if one isn't already assigned.
*/
case SEARCH_FOR_LZ:
if (Height == 0 && (Target_Legal(NavCom) || Coord == As_Coord(NavCom))) {
Status = UNLOAD_PASSENGERS;
} else {
if (!Is_LZ_Clear(NavCom)) {
FootClass * foot = Attached_Object();
if (foot != NULL && foot->Team && foot->Team->Class->Origin != -1) {
Assign_Destination(::As_Target(Scen.Waypoint[foot->Team->Class->Origin]));
} else {
Assign_Destination(New_LZ(::As_Target(Scen.Waypoint[WAYPT_REINF])));
if (Team.Is_Valid()) {
Team->Assign_Mission_Target(NavCom);
}
}
} else {
if (Height == FLIGHT_LEVEL) {
Status = FLY_TO_LZ;
} else {
Status = TAKE_OFF;
}
}
}
break;
/*
** Fly to destination.
*/
case FLY_TO_LZ:
if (Is_LZ_Clear(NavCom)) {
int distance = Process_Fly_To(true, NavCom);
if (distance < 0x0100) {
SecondaryFacing.Set_Desired(Pose_Dir());
if (distance < 0x0010) {
Status = LAND_ON_LZ;
}
return(1);
} else {
SecondaryFacing.Set_Desired(PrimaryFacing.Desired());
return(5);
}
} else {
Status = SEARCH_FOR_LZ;
}
break;
/*
** Landing phase. Just delay until landing is complete. At that time,
** transition to the unloading phase.
*/
case LAND_ON_LZ:
if (IsTakingOff) {
Status = TAKE_OFF;
} else {
if (Process_Landing()) {
Status = UNLOAD_PASSENGERS;
}
}
return(1);
/*
** Hold while unloading passengers. When passengers are unloaded the order for this
** transport gets changed to MISSION_RETREAT.
*/
case UNLOAD_PASSENGERS:
if (!IsTethered) {
if (Is_Something_Attached()) {
FootClass * unit = (FootClass *)Detach_Object();
/*
** First thing is to lift the transport off of the map so that the unlimbo
** process for the passengers is more likely to succeed.
*/
Map.Pick_Up(Coord_Cell(Coord), this);
if (!Exit_Object(unit)) {
delete unit;
}
/*
** Restore the transport back down on the map.
*/
Map.Place_Down(Coord_Cell(Coord), this);
if (!Is_Something_Attached()) {
Enter_Idle_Mode();
}
} else {
Enter_Idle_Mode();
}
}
break;
/*
** Aircraft is now taking off. Once the aircraft reaches flying altitude then it
** will either take off or look for another landing spot to try again.
*/
case TAKE_OFF: {
if (Process_Take_Off()) {
if (Is_Something_Attached()) {
Status = SEARCH_FOR_LZ;
/*
** Break off radio contact with the helipad it is taking off from.
*/
if (In_Radio_Contact() && Map[Coord].Cell_Building() == Contact_With_Whom()) {
Transmit_Message(RADIO_OVER_OUT);
}
} else {
Enter_Idle_Mode();
}
}
return(1);
}
default:
break;
}
}
return(MissionControl[Mission].Normal_Delay() + Random_Pick(0, 2));
}
/***********************************************************************************************
* AircraftClass::Is_LZ_Clear -- Determines if landing zone is free for landing. *
* *
* This routine examines the landing zone (as specified by the target parameter) in order *
* to determine if it is free to be landed upon. Call this routine when it is necessary *
* to double check this. Typically this occurs right before a helicopter lands and also *
* when determining the landing zone in the first place. *
* *
* INPUT: target -- The target that is the "landing zone". *
* *
* OUTPUT: bool; Is the landing zone clear for landing? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/31/94 JLB : Created. *
*=============================================================================================*/
bool AircraftClass::Is_LZ_Clear(TARGET target) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (!Target_Legal(target)) return(false);
CELL cell = ::As_Cell(target);
if (!Map.In_Radar(cell)) return(false);
/*
** If the requested landing location is occupied, then only consider that location
** legal if the occupying object is in radio contact with the aircraft. This presumes that
** the two objects know what they are doing.
*/
ObjectClass * object = Map[cell].Cell_Object();
if (object) {
if (object == this) return(true);
if (In_Radio_Contact() && Contact_With_Whom() == object) {
return(true);
}
return(false);
}
if (!Map[cell].Is_Clear_To_Move(SPEED_TRACK, false, false)) return(false);
return(true);
}
/***********************************************************************************************
* AircraftClass::Sort_Y -- Figures the sorting coordinate. *
* *
* This routine is used to determine the coordinate to use for sorting the aircraft. This *
* sorting value is used when the aircraft is on the ground. At that time the aircraft *
* must be rendered in proper relationship to the other ground objects. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the coordinate to use when sorting the aircraft with other ground *
* objects. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 11/02/1994 JLB : Created. *
*=============================================================================================*/
COORDINATE AircraftClass::Sort_Y(void) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
return(Coord_Add(Coord, 0x00800000L));
}
/***********************************************************************************************
* AircraftClass::Mission_Retreat -- Handles the aircraft logic for leaving the battlefield. *
* *
* This mission will be followed when the aircraft decides that it is time to leave the *
* battle. Typically, this occurs when a loaner transport has dropped off its load or when *
* an attack air vehicle has expended its ordinance. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the number of game ticks to delay before calling this routine again. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/19/1995 JLB : Created. *
* 08/13/1995 JLB : Handles aircraft altitude gain after takeoff logic. *
*=============================================================================================*/
int AircraftClass::Mission_Retreat(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (Class->IsFixedWing) {
if (Class->IsFixedWing && Height < FLIGHT_LEVEL) {
Height += 1;
return(3);
}
return(TICKS_PER_SECOND*10);
}
enum {
TAKE_OFF,
FACE_MAP_EDGE,
KEEP_FLYING
};
switch (Status) {
/*
** Take off if landed.
*/
case TAKE_OFF:
if (Process_Take_Off()) {
Status = FACE_MAP_EDGE;
}
return(1);
/*
** Set facing and speed toward the friendly map edge.
*/
case FACE_MAP_EDGE:
Set_Speed(0xFF);
/*
** Take advantage of the fact that the source map edge enumerations happen to
** occur in a clockwise order and are the first four enumerations of the map
** edge default for the house. If this value is masked and then shifted, a
** normalized direction value results. Use this value to head the aircraft
** toward the "friendly" map edge.
*/
PrimaryFacing.Set_Desired((DirType)((House->Control.Edge & 0x03) << 6));
SecondaryFacing.Set_Desired(PrimaryFacing.Desired());
Status = KEEP_FLYING;
break;
/*
** Just do nothing since we are headed toward the map edge. When the edge is
** reached, the aircraft should be automatically eliminated.
*/
case KEEP_FLYING:
break;
default:
break;
}
return(MissionControl[Mission].Normal_Delay() + Random_Pick(0, 2));
}
/***********************************************************************************************
* AircraftClass::Exit_Object -- Unloads passenger from aircraft. *
* *
* This routine is called when the aircraft is to unload a passenger. The passenger must *
* be able to move under its own power. Typical situation is when a transport helicopter *
* is to unload an infantry unit. *
* *
* INPUT: unit -- Pointer to the unit that is to be unloaded from this aircraft. *
* *
* OUTPUT: bool; Was the unit unloaded successfully? *
* *
* WARNINGS: The unload process is merely started by this routine. Radio contact is *
* established with the unloading unit and when the unit is clear of the aircraft *
* the radio contact will be broken and then the aircraft is free to pursue *
* other. *
* *
* HISTORY: *
* 01/10/1995 JLB : Created. *
*=============================================================================================*/
int AircraftClass::Exit_Object(TechnoClass * unit)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
static FacingType _toface[FACING_COUNT] = {FACING_S, FACING_SW, FACING_SE, FACING_NW, FACING_NE, FACING_N, FACING_W, FACING_E};
CELL cell;
/*
** Find a free cell to drop the unit off at.
*/
FacingType face;
for (face = FACING_N; face < FACING_COUNT; face++) {
cell = Adjacent_Cell(Coord_Cell(Coord), _toface[face]);
if (unit->Can_Enter_Cell(cell) == MOVE_OK) break;
}
// Should perform a check here to see if no cell could be found.
/*
** If the passenger can be placed on the map, then start it moving toward the
** destination cell and establish radio contact with the transport. This is used
** to make sure that the transport waits until the passenger is clear before
** unloading the next passenger or taking off.
*/
if (unit->Unlimbo(Coord, Facing_Dir(_toface[face]))) {
unit->Assign_Mission(MISSION_MOVE);
unit->Assign_Destination(::As_Target(cell));
if (Transmit_Message(RADIO_HELLO, unit) == RADIO_ROGER) {
Transmit_Message(RADIO_UNLOAD);
}
unit->Look(false);
return(true);
}
return(false);
}
/***********************************************************************************************
* AircraftClass::Paradrop_Cargo -- Drop a passenger by parachute. *
* *
* Call this routine when a passenger needs to be dropped off by parachute. One passenger *
* is offloaded by a call to this routine. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the delay time that it is safe to wait before processing any further *
* paradrop actions. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/26/1996 JLB : Created. *
*=============================================================================================*/
int AircraftClass::Paradrop_Cargo(void)
{
FootClass * passenger = Detach_Object();
if (passenger) {
if (!passenger->Paradrop(Center_Coord())) {
Attach(passenger);
} else {
/*
** Play a sound effect of the parachute opening.
*/
Sound_Effect(VOC_CHUTE1, Coord);
if (Team.Is_Valid()) {
Team->Remove(passenger);
if (passenger->House->IsHuman) {
Assign_Mission(MISSION_GUARD);
} else {
Assign_Mission(MISSION_HUNT);
}
}
// Arm = Rearm_Delay(IsSecondShot);
Arm = 0;
}
}
return(Arm);
}
/***********************************************************************************************
* AircraftClass::Fire_At -- Handles firing a projectile from an aircraft. *
* *
* Sometimes, aircraft firing needs special handling. Example: for napalm bombs, the *
* bomb travels forward at nearly the speed of the delivery aircraft, not necessarily the *
* default speed defined in the BulletTypeClass structure. *
* *
* INPUT: target -- The target that the projectile is heading for. *
* *
* which -- Which weapon to use in the attack. 0=primary, 1=secondary. *
* *
* OUTPUT: Returns with a pointer to the bullet that was created as a result of this attack. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/19/1995 JLB : Created. *
*=============================================================================================*/
BulletClass * AircraftClass::Fire_At(TARGET target, int which)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
/*
** Passenger aircraft will actually paradrop their cargo instead of
** firing their weapon.
*/
if (Is_Something_Attached()) {
Paradrop_Cargo();
return(0);
}
/*
** If the weapon is actually a camera, then perform the "snapshot" of the
** ground instead of normal weapon fire.
*/
if (Class->PrimaryWeapon != NULL && Class->PrimaryWeapon->IsCamera) {
if (Session.Type != GAME_GLYPHX_MULTIPLAYER) {
if (House->Is_Ally(PlayerPtr)) {
Map.Sight_From(Coord_Cell(Center_Coord()), 9, House, false);
}
} else {
for (int i = 0; i < Session.Players.Count(); i++) {
HousesType house_type = Session.Players[i]->Player.ID;
HouseClass *house = HouseClass::As_Pointer(house_type);
if (house == House || House->Is_Ally(house)) {
Map.Sight_From(Coord_Cell(Center_Coord()), 9, house, false);
}
}
}
Ammo = 0;
Arm = Rearm_Delay(IsSecondShot);
return(0);
}
BulletClass * bullet = FootClass::Fire_At(target, which);
if (bullet) {
/*
** Aircraft reveal when firing
*/
HouseClass *player = HouseClass::As_Pointer(Owner());
if (player != nullptr && player->IsHuman) {
Map.Sight_From(Coord_Cell(Center_Coord()), 1, player, false);
}
/*
** Falling bullets move at a speed proportionate to the delivery craft.
*/
if (bullet->Class->IsDropping) {
bullet->Fly_Speed(40, MPH_MEDIUM_SLOW); // TCTC To fix.
}
}
return(bullet);
}
/***********************************************************************************************
* AircraftClass::Take_Damage -- Applies damage to the aircraft. *
* *
* This routine is used to apply damage to the specified aircraft. This is where any *
* special crash animation will be initiated. *
* *
* INPUT: damage -- Reference to the damage that will be applied to the aircraft. *
* This value will be filled in with the actual damage that was *
* applied. *
* *
* distance -- Distance from the source of the explosion to this aircraft. *
* *
* warhead -- The warhead type that the damage occurs from. *
* *
* source -- Pointer to the originator of the damage. This can be used so that *
* proper "thank you" can be delivered. *
* *
* OUTPUT: Returns with the result of the damage as it affects this aircraft. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/26/1995 JLB : Created. *
*=============================================================================================*/
ResultType AircraftClass::Take_Damage(int & damage, int distance, WarheadType warhead, TechnoClass * source, bool forced)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
ResultType res = RESULT_NONE;
/*
** Flying aircraft take half damage.
*/
if (Height) {
damage /= 2;
}
/*
** Apply the damage to the aircraft.
*/
res = FootClass::Take_Damage(damage, distance, warhead, source, forced);
/*
** Special action is performed if the aircraft is killed -- the cargo is destroyed
** as well.
*/
switch (res) {
case RESULT_DESTROYED:
{
Kill_Cargo(source);
Death_Announcement();
COORDINATE coord = Target_Coord();
if (!(coord & HIGH_COORD_MASK)) {
new AnimClass(ANIM_FBALL1, coord);
}
/*
** Parachute a survivor if possible.
*/
if (Class->IsCrew && Percent_Chance(90) && Map[Center_Coord()].Is_Clear_To_Move(SPEED_FOOT, true, false)) {
InfantryClass * infantry = new InfantryClass(INFANTRY_E1, House->Class->House);
if (infantry != NULL) {
if (!infantry->Paradrop(Center_Coord())) {
delete infantry;
}
}
}
delete this;
}
break;
default:
case RESULT_HALF:
break;
}
return(res);
}
/***********************************************************************************************
* AircraftClass::Mission_Move -- Handles movement mission. *
* *
* This state machine routine is used when an aircraft (usually helicopter) is to move *
* from one location to another. It will handle any necessary take off and landing this *
* may require. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the number of game frames that should elapse before this routine *
* is called again. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
*=============================================================================================*/
int AircraftClass::Mission_Move(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (Class->IsFixedWing) {
enum {
TAKE_OFF,
FLY_TOWARD_TARGET
};
switch (Status) {
int distance;
case TAKE_OFF:
/*
** If the aircraft is high enough to begin its mission, then do so.
*/
if (Process_Take_Off()) {
IsTakingOff = false;
Set_Speed(0xFF);
/*
** After takeoff is complete, break radio contact.
*/
if (In_Radio_Contact() && Map[Coord].Cell_Building() == Contact_With_Whom()) {
Transmit_Message(RADIO_OVER_OUT);
}
Status = FLY_TOWARD_TARGET;
}
return(1);
case FLY_TOWARD_TARGET:
PrimaryFacing.Set_Desired(Direction(NavCom));
distance = Distance(NavCom);
if (distance < 0x00C0) {
MissionType mission = MISSION_GUARD;
if (!IsALoaner) {
/*
** Normal aircraft try to find a good landing spot to rest.
*/
BuildingClass * building = Find_Docking_Bay(Class->Building, false);
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if (!Class->IsFixedWing) {
int dist = 0x7FFFFFFF;
if (building) dist=Distance(building);
for (int index = 0; index < Vessels.Count(); index++) {
VesselClass *ship = Vessels.Ptr(index);
if (ship != NULL && *ship == VESSEL_CARRIER && !ship->IsInLimbo && ship->IsActive && ship->House == House && ship->How_Many() < ship->Class->Max_Passengers() ) {
if (Distance(ship) < dist || !building) {
building = (BuildingClass *)ship;
dist = Distance(ship);
}
// break;
}
}
}
#endif
Assign_Destination(TARGET_NONE);
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if (building && (Transmit_Message(RADIO_HELLO, building) == RADIO_ROGER || building->What_Am_I() == RTTI_VESSEL) ) {
#else
if (building && Transmit_Message(RADIO_HELLO, building) == RADIO_ROGER) {
#endif
mission = MISSION_ENTER;
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if (building->What_Am_I() == RTTI_VESSEL) {
Assign_Destination(building->As_Target());
}
#endif
} else {
Assign_Destination(Good_LZ());
/*
** If this aircraft has nowhere else to go, meaning that
** there is no airfield available, then it has to crash.
*/
if (Is_Target_Cell(NavCom)) {
if (Process_Landing()) {
Strength = 1;
int damage = Strength;
Take_Damage(damage, 0, WARHEAD_AP, 0, true);
return(1);
}
return(500);
}
mission = MISSION_MOVE;
}
Assign_Mission(mission);
Commence();
} else {
if (!Team.Is_Valid()) {
Enter_Idle_Mode();
}
}
return(1);
}
break;
default:
break;
}
return(5);
}
enum {
VALIDATE_LZ,
TAKE_OFF,
FLY_TO_LZ,
LAND
};
switch (Status) {
/*
** Double check and change LZ if necessary.
*/
case VALIDATE_LZ:
if (!Target_Legal(NavCom)) {
Enter_Idle_Mode();
} else {
if (!Is_LZ_Clear(NavCom) || !Cell_Seems_Ok(As_Cell(NavCom))) {
Assign_Destination(New_LZ(NavCom));
if (Team.Is_Valid()) {
Team->Assign_Mission_Target(NavCom);
}
} else {
Status = TAKE_OFF;
}
}
break;
/*
** Take off if necessary.
*/
case TAKE_OFF:
if (!Target_Legal(NavCom)) {
Status = VALIDATE_LZ;
} else {
if (Process_Take_Off()) {
/*
** After takeoff is complete, break radio contact with any helipad that this
** helicopter is taking off from.
*/
if (In_Radio_Contact() && Map[Coord].Cell_Building() == Contact_With_Whom()) {
Transmit_Message(RADIO_OVER_OUT);
}
Status = FLY_TO_LZ;
}
return(1);
}
break;
/*
** Fly toward target.
*/
case FLY_TO_LZ:
if (Is_LZ_Clear(NavCom)) {
int distance = Process_Fly_To(true, NavCom);
if (distance < 0x0080) {
if (Target_Legal(TarCom)) {
SecondaryFacing.Set_Desired(Direction(TarCom));
} else {
SecondaryFacing.Set_Desired(Pose_Dir());
}
if (distance < 0x0010) {
Status = LAND;
}
return(1);
}
// SecondaryFacing.Set_Desired(::Direction(Fire_Coord(0), As_Coord(NavCom)));
SecondaryFacing.Set_Desired(Direction(NavCom));
} else {
Assign_Destination(New_LZ(NavCom));
if (Team.Is_Valid()) {
Team->Assign_Mission_Target(NavCom);
}
if (!Target_Legal(NavCom)) {
Status = LAND;
}
}
return(1);
/*
** Land on target.
*/
case LAND:
if (IsTakingOff) {
Assign_Destination(New_LZ(NavCom));
if (Team.Is_Valid()) {
Team->Assign_Mission_Target(NavCom);
}
Status = TAKE_OFF;
}
if (Process_Landing()) {
if (MissionQueue == MISSION_NONE) {
Enter_Idle_Mode();
}
}
return(1);
default:
break;
}
return(MissionControl[Mission].Normal_Delay() + Random_Pick(0, 2));
}
/***********************************************************************************************
* AircraftClass::Enter_Idle_Mode -- Gives the aircraft an appropriate mission. *
* *
* Use this routine when the mission for the aircraft is in doubt. This routine will find *
* an appropriate mission for the aircraft and dispatch it. *
* *
* INPUT: initial -- Is this called when the unit just leaves a factory or is initially *
* or is initially placed on the map? *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/05/1995 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Enter_Idle_Mode(bool )
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
MissionType mission = (Class->IsFixedWing && IsALoaner && Class->PrimaryWeapon != NULL) ? MISSION_HUNT : MISSION_GUARD;
if (Class->IsFixedWing) {
if (In_Which_Layer() == LAYER_GROUND) {
if (IsALoaner) {
mission = MISSION_RETREAT;
} else {
Assign_Destination(TARGET_NONE);
Assign_Target(TARGET_NONE);
mission = MISSION_GUARD;
}
} else {
/*
** If this transport is a loaner and part of a team, then remove it from
** the team it is attached to.
*/
if ((IsALoaner && House->IsHuman) || (!House->IsHuman && !Ammo)) {
if (Team.Is_Valid() && Team->Has_Entered_Map()) {
Team->Remove(this);
}
}
if (Team.Is_Valid()) return;
/*
** Weapon equipped helicopters that run out of ammo and were
** brought in as reinforcements will leave the map.
*/
if (Mission != MISSION_ATTACK && IsALoaner && Ammo == 0 && Class->PrimaryWeapon != NULL) {
mission = MISSION_HUNT;
} else {
if (!IsALoaner) {
/*
** Normal aircraft try to find a good landing spot to rest.
*/
BuildingClass * building = NULL;
if (In_Radio_Contact() && Contact_With_Whom()->What_Am_I() == RTTI_BUILDING) {
building = (BuildingClass *)Contact_With_Whom();
} else {
building = Find_Docking_Bay(Class->Building, false);
if (Transmit_Message(RADIO_HELLO, building) != RADIO_ROGER) {
building = NULL;
}
}
Assign_Destination(TARGET_NONE);
if (building != NULL) {
if (Class->IsFixedWing) {
Status = 0; //BG - reset the mission status to avoid landing on the ground next to the airstrip
if (IsLanding) {
Process_Take_Off();
}
}
mission = MISSION_ENTER;
} else {
mission = MISSION_RETREAT;
}
}
}
}
} else {
if (In_Which_Layer() == LAYER_GROUND) {
if (IsALoaner) {
if (Is_Something_Attached()) {
/*
** In the case of a computer controlled helicopter that hold passengers,
** don't unload when landing. Wait for specific instructions from the
** controlling team.
*/
if (Team.Is_Valid()) {
// if (Team.Is_Valid() && !House->IsHuman) {
mission = MISSION_GUARD;
} else {
mission = MISSION_UNLOAD;
}
} else {
mission = MISSION_RETREAT;
}
} else {
Assign_Destination(TARGET_NONE);
Assign_Target(TARGET_NONE);
mission = MISSION_GUARD;
}
} else {
if (Is_Something_Attached()) {
if (IsALoaner) {
if (Team) {
mission = MISSION_GUARD;
} else {
mission = MISSION_UNLOAD;
Assign_Destination(Good_LZ());
}
} else {
Assign_Destination(Good_LZ());
mission = MISSION_MOVE;
}
} else {
/*
** If this transport is a loaner and part of a team, then remove it from
** the team it is attached to.
*/
if ((IsALoaner && House->IsHuman) || (!House->IsHuman && !Ammo)) {
if (Team.Is_Valid() && Team->Has_Entered_Map()) {
Team->Remove(this);
}
}
if (Class->PrimaryWeapon != NULL) {
/*
** Weapon equipped helicopters that run out of ammo and were
** brought in as reinforcements will leave the map.
*/
if (IsALoaner) {
/*
** If it has no ammo, then break off of the team and leave the map.
** If it can fight, then give it fighting orders.
*/
if (Ammo == 0) {
if (Team.Is_Valid()) Team->Remove(this);
mission = MISSION_RETREAT;
} else {
if (!Team.Is_Valid()) {
mission = MISSION_HUNT;
}
}
} else {
/*
** Normal aircraft try to find a good landing spot to rest.
*/
BuildingClass * building = Find_Docking_Bay(Class->Building, false);
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if (!Class->IsFixedWing) {
int dist = 0x7FFFFFFF;
if (building) dist=Distance(building);
for (int index = 0; index < Vessels.Count(); index++) {
VesselClass *ship = Vessels.Ptr(index);
if (ship != NULL && *ship == VESSEL_CARRIER && !ship->IsInLimbo && ship->IsActive && ship->House == House && ship->How_Many() < ship->Class->Max_Passengers()/* && !ship->In_Radio_Contact()*/) {
if (Distance(ship) < dist || !building) {
building = (BuildingClass *)ship;
dist = Distance(ship);
}
// break;
}
}
}
#endif
Assign_Destination(TARGET_NONE);
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if (building && (Transmit_Message(RADIO_HELLO, building) == RADIO_ROGER || building->What_Am_I() == RTTI_VESSEL) ) {
#else
if (building && Transmit_Message(RADIO_HELLO, building) == RADIO_ROGER) {
#endif
mission = MISSION_ENTER;
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if (building->What_Am_I() == RTTI_VESSEL) {
Assign_Destination(building->As_Target());
}
#endif
} else {
Assign_Destination(Good_LZ());
mission = MISSION_MOVE;
}
}
} else {
if (Team) return;
Assign_Destination(Good_LZ());
mission = MISSION_MOVE;
}
}
}
}
Assign_Mission(mission);
Commence();
}
/***********************************************************************************************
* AircraftClass::Process_Fly_To -- Handles state machine for flying to destination. *
* *
* This support routine is used when the helicopter is to fly to the destination. It can *
* optionally slow the helicopter down as it approaches the destination. *
* *
* INPUT: slowdown -- Should the aircraft be slowed down when it approaches the dest? *
* *
* OUTPUT: Returns with the distance remaining between the aircraft and the destination. *
* *
* WARNINGS: Because the aircraft can move at a fast speed, the distance to target value *
* will probably never be zero. The likely case will be that the aircraft *
* overshoots the target. *
* *
* HISTORY: *
* 06/14/1995 JLB : Created. *
* 03/05/1996 JLB : Specifies destination target value. *
*=============================================================================================*/
int AircraftClass::Process_Fly_To(bool slowdown, TARGET dest)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (Class->IsFixedWing) slowdown = false;
COORDINATE coord;
if (Is_Target_Building(dest)) {
coord = As_Building(dest)->Docking_Coord();
} else {
coord = As_Coord(dest);
}
int distance = Distance(coord);
PrimaryFacing.Set_Desired(Direction(coord));
if (slowdown) {
int speed = min(distance, 0x0300);
speed = Bound(speed/3, 0x0020, 0x00FF);
if (Speed != speed) {
Set_Speed(speed);
}
}
if (distance < 0x0010) {
if (slowdown) {
Set_Speed(0);
}
distance = 0;
}
return(distance);
}
#ifdef CHEAT_KEYS
/***********************************************************************************************
* AircraftClass::Debug_Dump -- Displays the status of the aircraft to the mono monitor. *
* *
* This displays the current status of the aircraft class to the mono monitor. By this *
* display bugs may be tracked down or prevented. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/02/1994 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Debug_Dump(MonoClass * mono) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
mono->Set_Cursor(0, 0);
mono->Print(Text_String(TXT_DEBUG_AIRCRAFT));
mono->Set_Cursor(1, 11);mono->Printf("%3d", AttacksRemaining);
FootClass::Debug_Dump(mono);
}
#endif
/***********************************************************************************************
* AircraftClass::Active_Click_With -- Handles clicking over specified object. *
* *
* This routine is used when the player clicks over the speicifed object. It will assign *
* the appropriate mission to the aircraft. *
* *
* INPUT: action -- The action that was nominally determined by the What_Action function. *
* *
* object -- The object over which the mouse was clicked. *
* *
* OUTPUT: none *
* *
* WARNINGS: This routine will alter the game sequence and causes an event packet to be *
* propagated to all connected machines. *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Active_Click_With(ActionType action, ObjectClass * object)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
action = What_Action(object);
switch (action) {
case ACTION_NOMOVE:
return;
case ACTION_ENTER:
Player_Assign_Mission(MISSION_ENTER, TARGET_NONE, object->As_Target());
break;
case ACTION_SELF:
Player_Assign_Mission(MISSION_UNLOAD, TARGET_NONE, TARGET_NONE);
break;
default:
break;
}
FootClass::Active_Click_With(action, object);
}
/***********************************************************************************************
* AircraftClass::Active_Click_With -- Handles clicking over specified cell. *
* *
* This routine is used when the player clicks the mouse of the specified cell. It will *
* assign the appropriate mission to the aircraft. *
* *
* INPUT: action -- The action nominally determined by What_Action(). *
* *
* cell -- The cell over which the mouse was clicked. *
* *
* OUTPUT: none *
* *
* WARNINGS: This routine will affect the game sequence and causes an event object to be *
* propagated to all connected machines. *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Active_Click_With(ActionType action, CELL cell)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
FootClass::Active_Click_With(action, cell);
}
/***********************************************************************************************
* AircraftClass::Player_Assign_Mission -- Handles player input to assign a mission. *
* *
* This routine is called as a result of player input with the intent to change the *
* mission of the aircraft. *
* *
* INPUT: mission -- The mission requested of the aircraft. *
* *
* target -- The value to assign to the aircraft's targeting computer. *
* *
* dest. -- The value to assign to the aircraft's navigation computer. *
* *
* OUTPUT: none *
* *
* WARNINGS: The mission specified will be executed at an indeterminate future game frame. *
* This is controlled by net/modem propagation delay. *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Player_Assign_Mission(MissionType mission, TARGET target, TARGET destination)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (AllowVoice) {
if (mission == MISSION_ATTACK) {
Response_Attack();
} else {
Response_Move();
}
}
Queue_Mission(TargetClass(this), mission, target, destination);
}
/***********************************************************************************************
* AircraftClass::What_Action -- Determines what action to perform. *
* *
* This routine is used to determine what action will likely be performed if the mouse *
* were clicked over the object specified. The display system calls this routine to *
* control the mouse shape. *
* *
* INPUT: target -- Pointer to the object that the mouse is currently over. *
* *
* OUTPUT: Returns with the action that will occur if the mouse were clicked over the *
* object specified. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
*=============================================================================================*/
ActionType AircraftClass::What_Action(ObjectClass const * target) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
ActionType action = FootClass::What_Action(target);
if (action == ACTION_SELF && (!How_Many() || (Height > 0) || IsTethered)) {
action = ACTION_NONE;
}
if (action == ACTION_ATTACK && Class->PrimaryWeapon == NULL) {
action = ACTION_NONE;
}
if (House->IsPlayerControl && House->Is_Ally(target) && target->What_Am_I() == RTTI_BUILDING && ((AircraftClass *)this)->Transmit_Message(RADIO_CAN_LOAD, (TechnoClass*)target) == RADIO_ROGER) {
action = ACTION_ENTER;
}
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if (!Class->IsFixedWing && House->IsPlayerControl && House->Is_Ally(target) && target->What_Am_I() == RTTI_VESSEL && *(VesselClass *)target == VESSEL_CARRIER && ((AircraftClass *)this)->Transmit_Message(RADIO_CAN_LOAD, (TechnoClass*)target) == RADIO_ROGER) {
action = ACTION_ENTER;
}
#endif
if (Class->IsFixedWing && action == ACTION_MOVE) {
action = ACTION_NOMOVE;
}
if (action == ACTION_NONE) {
action = What_Action(Coord_Cell(target->Center_Coord()));
}
/*
** Special return to friendly repair factory action.
*/
if (House->IsPlayerControl && action == ACTION_SELECT && target->What_Am_I() == RTTI_BUILDING) {
BuildingClass * building = (BuildingClass *)target;
if (building->Class->Type == STRUCT_REPAIR && !building->In_Radio_Contact() && !building->Is_Something_Attached()) {
action = ACTION_ENTER;
}
}
return(action);
}
/***********************************************************************************************
* AircraftClass::What_Action -- Determines what action to perform. *
* *
* This routine will determine what action would occur if the mouse were clicked over the *
* cell specified. The display system calls this routine to determine what mouse shape *
* to use. *
* *
* INPUT: cell -- The cell over which the mouse is currently positioned. *
* *
* OUTPUT: Returns with the action that will be performed if the mouse were clicked at the *
* specified cell location. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
*=============================================================================================*/
ActionType AircraftClass::What_Action(CELL cell) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
ActionType action = FootClass::What_Action(cell);
//using function for IsVisible so we have different results for different players - JAS 2019/09/30
if ((action == ACTION_MOVE || action == ACTION_ATTACK) && !Map[cell].Is_Visible(PlayerPtr)) {
action = ACTION_NOMOVE;
}
if (action == ACTION_ATTACK && Class->PrimaryWeapon == NULL) {
action = ACTION_NONE;
}
if (Class->IsFixedWing && action == ACTION_MOVE) {
action = ACTION_NOMOVE;
}
return(action);
}
/***********************************************************************************************
* AircraftClass::Pose_Dir -- Fetches the natural landing facing. *
* *
* Use this routine to get the desired facing the aircraft should assume when landing. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the normal default facing the aircraft should have when landed. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
* 03/04/1996 JLB : Fixed wing aircraft always face down the runway. *
*=============================================================================================*/
DirType AircraftClass::Pose_Dir(void) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (*this == AIRCRAFT_TRANSPORT) {
return(DIR_N);
}
if (Class->IsFixedWing) {
return(DIR_E);
}
return(DIR_NE);
}
/***********************************************************************************************
* AircraftClass::Mission_Attack -- Handles the attack mission for aircraft. *
* *
* This routine is the state machine that handles the attack mission for aircraft. It will *
* handling homing in on and firing on the target in the aircraft's targeting computer. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the number of game ticks to pass before this routine must be called *
* again. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
* 09/22/1995 JLB : Fixes brain dead helicopter for Nod scen #7. *
*=============================================================================================*/
int AircraftClass::Mission_Attack(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (Class->IsFixedWing) {
return(Mission_Hunt());
}
enum {
VALIDATE_AZ,
PICK_ATTACK_LOCATION,
TAKE_OFF,
FLY_TO_POSITION,
FIRE_AT_TARGET,
FIRE_AT_TARGET2,
RETURN_TO_BASE
};
switch (Status) {
/*
** Double check target and validate the attack zone.
*/
case VALIDATE_AZ:
if (!Target_Legal(TarCom)) {
Status = RETURN_TO_BASE;
} else {
Status = PICK_ATTACK_LOCATION;
}
break;
/*
** Pick a good location to attack from.
*/
case PICK_ATTACK_LOCATION:
if (!Target_Legal(TarCom)) {
Status = RETURN_TO_BASE;
} else {
Assign_Destination(Good_Fire_Location(TarCom));
if (Target_Legal(NavCom)) {
Status = TAKE_OFF;
} else {
Status = RETURN_TO_BASE;
}
}
break;
/*
** Take off (if necessary).
*/
case TAKE_OFF:
if (!Target_Legal(TarCom)) {
Status = RETURN_TO_BASE;
} else {
if (Process_Take_Off()) {
Status = FLY_TO_POSITION;
/*
** Break off radio contact with the helipad it is taking off from.
*/
if (In_Radio_Contact() && Map[Coord].Cell_Building() == Contact_With_Whom()) {
Transmit_Message(RADIO_OVER_OUT);
}
/*
** Start flying toward the destination by skewing at first.
** As the flight progresses, the body will rotate to face
** the direction of travel.
*/
int diff = SecondaryFacing.Difference(Direction(NavCom));
diff = Bound(diff, -128, 128);
PrimaryFacing = DirType((int)SecondaryFacing.Current()+diff);
}
return(1);
}
break;
/*
** Fly to attack location.
*/
case FLY_TO_POSITION:
if (Target_Legal(TarCom)) {
/*
** If the navcom was cleared mysteriously, then try to pick
** a new attack location. This is a likely event if the player
** clicks on a new target while in flight to an existing target.
*/
if (!Target_Legal(NavCom)) {
Status = PICK_ATTACK_LOCATION;
return(1);
}
int distance = Process_Fly_To(true, NavCom);
if (distance < 0x0200) {
SecondaryFacing.Set_Desired(Direction(TarCom));
if (distance < 0x0010) {
Status = FIRE_AT_TARGET;
Assign_Destination(TARGET_NONE);
}
} else {
SecondaryFacing.Set_Desired(::Direction(Fire_Coord(0), As_Coord(NavCom)));
return(1);
}
} else {
Status = RETURN_TO_BASE;
}
return(1);
/*
** Fire at the target.
*/
case FIRE_AT_TARGET:
if (!Target_Legal(TarCom)) {
Status = RETURN_TO_BASE;
return(1);
}
PrimaryFacing.Set_Desired(Direction(TarCom));
SecondaryFacing.Set_Desired(Direction(TarCom));
switch (Can_Fire(TarCom, 0)) {
case FIRE_CLOAKED:
Do_Uncloak();
break;
case FIRE_OK:
Fire_At(TarCom, 0);
Map[::As_Cell(TarCom)].Incoming(Coord, true);
Status = FIRE_AT_TARGET2;
break;
case FIRE_REARM:
case FIRE_FACING:
break;
default:
if (!Ammo) {
Status = RETURN_TO_BASE;
} else {
Status = FIRE_AT_TARGET2;
}
break;
}
return(1);
/*
** Fire at the target.
*/
case FIRE_AT_TARGET2:
if (!Target_Legal(TarCom)) {
Status = RETURN_TO_BASE;
return(1);
}
PrimaryFacing.Set_Desired(Direction(TarCom));
SecondaryFacing.Set_Desired(Direction(TarCom));
switch (Can_Fire(TarCom, 0)) {
case FIRE_CLOAKED:
Do_Uncloak();
break;
case FIRE_REARM:
break;
case FIRE_OK:
Fire_At(TarCom, 0);
Map[::As_Cell(TarCom)].Incoming(Coord, true);
if (Ammo) {
Status = Rule.IsCurleyShuffle ? PICK_ATTACK_LOCATION : FIRE_AT_TARGET;
} else {
Status = RETURN_TO_BASE;
}
break;
default:
if (!Ammo) {
Status = RETURN_TO_BASE;
} else {
if (!In_Range(TarCom)) {
Status = PICK_ATTACK_LOCATION;
} else {
Status = Rule.IsCurleyShuffle ? PICK_ATTACK_LOCATION : FIRE_AT_TARGET;
}
}
break;
}
break;
/*
** Fly back to landing spot.
*/
case RETURN_TO_BASE:
/*
** Break off of firing at the target if there is no more
** point in attacking it this mission. The player will
** reassign a target for the next mission.
*/
if (!Ammo && (IsALoaner || House->IsHuman)) {
Assign_Target(TARGET_NONE);
}
Assign_Destination(TARGET_NONE);
Enter_Idle_Mode();
break;
default:
break;
}
return(MissionControl[Mission].Normal_Delay() + Random_Pick(0, 2));
}
/***********************************************************************************************
* AircraftClass::New_LZ -- Find a good landing zone. *
* *
* Use this routine to locate a good landing zone that is nearby the location specified. *
* By using this routine it is possible to assign the same landing zone to several *
* aircraft and they will land nearby without conflict. *
* *
* INPUT: oldlz -- Target value of desired landing zone (usually a cell target value). *
* *
* OUTPUT: Returns with the new good landing zone. It might be the same value passed in. *
* *
* WARNINGS: The landing zone might be a goodly distance away from the ideal if there is *
* extensive blocking terrain in the vicinity. *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
*=============================================================================================*/
TARGET AircraftClass::New_LZ(TARGET oldlz) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (Target_Legal(oldlz) && (!Is_LZ_Clear(oldlz) || !Cell_Seems_Ok(As_Cell(oldlz)))) {
COORDINATE coord = As_Coord(oldlz);
/*
** Scan outward in a series of concentric rings up to certain distance
** in cells.
*/
for (int radius = 0; radius < Rule.LZScanRadius / CELL_LEPTON_W; radius++) {
FacingType modifier = Random_Pick(FACING_N, FACING_NW);
CELL lastcell = -1;
/*
** Perform a radius scan out from the original center location. Try to
** find a cell that is allowed to be a legal LZ.
*/
for (FacingType facing = FACING_N; facing < FACING_COUNT; facing++) {
CELL newcell = Coord_Cell(Coord_Move(coord, Facing_Dir(facing+modifier), radius * ICON_LEPTON_W));
if (Map.In_Radar(newcell)) {
TARGET newtarget = ::As_Target(newcell);
if (newcell != lastcell && Is_LZ_Clear(newtarget) && Cell_Seems_Ok(newcell)) {
return(newtarget);
}
lastcell = newcell;
}
}
}
}
return(oldlz);
}
/***********************************************************************************************
* AircraftClass::Receive_Message -- Handles receipt of radio messages. *
* *
* This routine receives all radio messages directed at this aircraft. It is used to handle *
* all inter-object coordination. Typically, this would be for transport helicopters and *
* other complex landing operations required of helicopters. *
* *
* INPUT: from -- The source of this radio message. *
* *
* message -- The message itself. *
* *
* param -- An optional parameter that may be used to transfer additional *
* data. *
* *
* OUTPUT: Returns with the radio response from the aircraft. *
* *
* WARNINGS: Some radio messages are handled by the base classes. *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
*=============================================================================================*/
RadioMessageType AircraftClass::Receive_Message(RadioClass * from, RadioMessageType message, long & param)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
switch (message) {
case RADIO_PREPARED:
if (Target_Legal(TarCom)) return(RADIO_NEGATIVE);
if ((Height == 0 && Ammo == Class->MaxAmmo) || (Height > 0 && Ammo > 0)) return(RADIO_ROGER);
return(RADIO_NEGATIVE);
/*
** Something disastrous has happened to the object in contact with. Fall back
** and regroup. This means that any landing process is immediately aborted.
*/
case RADIO_RUN_AWAY:
if (IsLanding) {
IsLanding = false;
IsTakingOff = true;
}
if (Class->IsFixedWing) {
Assign_Destination(Good_LZ());
if (!Target_Legal(NavCom)) {
Assign_Mission(MISSION_RETREAT);
} else {
Assign_Mission(MISSION_MOVE);
}
} else {
Scatter(0, true);
}
break;
/*
** The ground control requests that this specified landing spot be used.
*/
case RADIO_MOVE_HERE:
FootClass::Receive_Message(from, message, param);
if (Is_Target_Building(param)) {
if (Transmit_Message(RADIO_CAN_LOAD, As_Techno(param)) != RADIO_ROGER) {
return(RADIO_NEGATIVE);
}
Assign_Mission(MISSION_ENTER);
Assign_Destination((TARGET)param);
} else {
Assign_Mission(MISSION_MOVE);
Assign_Destination((TARGET)param);
}
Commence();
return(RADIO_ROGER);
/*
** Ground control is requesting if the aircraft requires navigation direction.
*/
case RADIO_NEED_TO_MOVE:
FootClass::Receive_Message(from, message, param);
if (!Target_Legal(NavCom) && !IsTakingOff && !IsLanding) {
return(RADIO_ROGER);
}
return(RADIO_NEGATIVE);
/*
** This message is sent by the passenger when it determines that it has
** entered the transport.
*/
case RADIO_IM_IN:
if (How_Many() == Class->Max_Passengers()) {
Close_Door(5, 4);
}
/*
** If a civilian has entered the transport, then the transport will immediately
** fly off the map.
*/
if (_Counts_As_Civ_Evac(from)) {
Assign_Mission(MISSION_RETREAT);
}
return(RADIO_ATTACH);
/*
** Docking maintenance message received. Check to see if new orders should be given
** to the impatient unit.
*/
case RADIO_DOCKING:
if (Class->Max_Passengers() > 0 && How_Many() < Class->Max_Passengers()) {
FootClass::Receive_Message(from, message, param);
if (!IsTethered && !IsLanding && !IsTakingOff && Height == 0) {
Open_Door(5, 4);
/*
** If the potential passenger needs someplace to go, then figure out a good
** spot and tell it to go.
*/
if (Transmit_Message(RADIO_NEED_TO_MOVE, from) == RADIO_ROGER) {
CELL cell;
/*DirType dir =*/ Desired_Load_Dir(from, cell);
/*
** If no adjacent free cells are detected, then passenger loading
** cannot occur. Break radio contact.
*/
if (cell == 0) {
Transmit_Message(RADIO_OVER_OUT, from);
} else {
param = (long)::As_Target(cell);
/*
** Tell the potential passenger where it should go. If the passenger is
** already at the staging location, then tell it to move onto the transport
** directly.
*/
if (Transmit_Message(RADIO_MOVE_HERE, param, from) == RADIO_YEA_NOW_WHAT) {
param = (long)As_Target();
Transmit_Message(RADIO_TETHER);
if (Transmit_Message(RADIO_MOVE_HERE, param, from) != RADIO_ROGER) {
Transmit_Message(RADIO_OVER_OUT, from);
} else {
Contact_With_Whom()->Unselect();
}
}
}
}
}
return(RADIO_ROGER);
}
break;
/*
** Asks if the passenger can load on this transport.
*/
case RADIO_CAN_LOAD:
if (Class->Max_Passengers() == 0 || from == NULL || !House->Is_Ally(from->Owner()) || Height > 0) return(RADIO_STATIC);
if (/*!In_Radio_Contact() &&*/ How_Many() < Class->Max_Passengers()) {
return(RADIO_ROGER);
}
return(RADIO_NEGATIVE);
default:
break;
}
/*
** Let the base class take over processing this message.
*/
return(FootClass::Receive_Message(from, message, param));
}
/***********************************************************************************************
* AircraftClass::Desired_Load_Dir -- Determines where passengers should line up. *
* *
* This routine is used by the transport helicopter to determine the location where the *
* infantry passengers should line up before loading. *
* *
* INPUT: object -- The object that is trying to load up on this transport. *
* *
* -- Reference to the cell that the passengers should move to before the *
* actual load process may begin. *
* *
* OUTPUT: Returns with the direction that the helicopter should face for the load operation. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/12/1995 JLB : Created. *
* 07/30/1995 JLB : Revamped to scan all adjacent cells. *
*=============================================================================================*/
DirType AircraftClass::Desired_Load_Dir(ObjectClass * object, CELL & moveto) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
CELL center = Coord_Cell(Center_Coord());
for (int sweep = FACING_N; sweep < FACING_S; sweep++) {
moveto = Adjacent_Cell(center, FacingType(FACING_S+sweep));
if (Map.In_Radar(moveto) && (Coord_Cell(object->Center_Coord()) == moveto || Map[moveto].Is_Clear_To_Move(SPEED_FOOT, false, false))) return(DIR_N);
moveto = Adjacent_Cell(center, FacingType(FACING_S-sweep));
if (Map.In_Radar(moveto) && (Coord_Cell(object->Center_Coord()) == moveto || Map[moveto].Is_Clear_To_Move(SPEED_FOOT, false, false))) return(DIR_N);
}
return(DIR_N);
}
/***********************************************************************************************
* AircraftClass::Process_Take_Off -- State machine support for taking off. *
* *
* This routine is used by the main game state machine processor. This utility routine *
* handles a helicopter as it transitions from landed to flying state. *
* *
* INPUT: none *
* *
* OUTPUT: Has the helicopter reached flight level now? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/12/1995 JLB : Created. *
*=============================================================================================*/
bool AircraftClass::Process_Take_Off(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
IsLanding = false;
IsTakingOff = true;
if (Class->IsFixedWing) {
Set_Speed(0xFF);
if (Height == FLIGHT_LEVEL) {
return(true);
}
} else {
switch (Height) {
case 0:
Close_Door(5, 4);
PrimaryFacing = SecondaryFacing;
break;
case FLIGHT_LEVEL/2:
PrimaryFacing.Set_Desired(Direction(NavCom));
break;
case FLIGHT_LEVEL-(FLIGHT_LEVEL/3):
SecondaryFacing.Set_Desired(PrimaryFacing.Desired());
Set_Speed(0x20);
break;
case FLIGHT_LEVEL-(FLIGHT_LEVEL/5):
Set_Speed(0x40);
break;
case FLIGHT_LEVEL:
Set_Speed(0xFF);
IsTakingOff = false;
return(true);
default:
break;
}
}
return(false);
}
/***********************************************************************************************
* AircraftClass::Process_Landing -- Landing process state machine handler. *
* *
* This is a support routine that is called by the main state machine routines. This *
* routine is responsible for handling the helicopter as it transitions from flight to *
* landing. *
* *
* INPUT: none *
* *
* OUTPUT: Has the helicopter completely landed now? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/12/1995 JLB : Created. *
* 03/04/1996 JLB : Handles fixed wing aircraft. *
*=============================================================================================*/
bool AircraftClass::Process_Landing(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
IsTakingOff = false;
IsLanding = true;
if (Class->IsFixedWing) {
int distance = Distance(NavCom);
if (distance > 0x0100) {
SecondaryFacing.Set_Desired(::Direction(Fire_Coord(0), As_Coord(NavCom)));
}
switch (Height) {
case 0:
Set_Speed(0);
IsLanding = false;
return(true);
default:
// if (distance*2 > Class->LandingSpeed) {
// Set_Speed(Class->LandingSpeed);
// } else {
// Set_Speed(distance/2);
// }
Set_Speed(Class->LandingSpeed / House->AirspeedBias);
break;
}
} else {
switch (Height) {
case 0:
IsLanding = false;
return(true);
case FLIGHT_LEVEL/2:
Set_Speed(0);
break;
case FLIGHT_LEVEL:
break;
default:
break;
}
}
return(false);
}
/***********************************************************************************************
* AircraftClass::Can_Enter_Cell -- Determines if the aircraft can land at this location. *
* *
* This routine is used when the passability of a cell needs to be determined. This is *
* necessary when scanning for a location that the aircraft can land. *
* *
* INPUT: cell -- The cell location to check for landing. *
* *
* OUTPUT: Returns a value indicating if the cell is a legal landing spot or not. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/12/1995 JLB : Created. *
*=============================================================================================*/
MoveType AircraftClass::Can_Enter_Cell(CELL cell, FacingType ) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (!Map.In_Radar(cell)) return(MOVE_NO);
CellClass * cellptr = &Map[cell];
ObjectClass const * occupier = cellptr->Cell_Occupier();
if (occupier == NULL ||
!occupier->Is_Techno() ||
((TechnoClass *)occupier)->House->Is_Ally(House) ||
(!((TechnoClass *)occupier)->Is_Cloaked(this) &&
(ScenarioInit == 0 && (occupier->What_Am_I() != RTTI_BUILDING || !((BuildingClass*)occupier)->Class->IsInvisible)) )
) {
if (!cellptr->Is_Clear_To_Move(SPEED_TRACK, false, false)) return(MOVE_NO);
}
if (Session.Type == GAME_NORMAL && IsOwnedByPlayer && !cellptr->IsMapped) {
return(MOVE_NO);
}
return(MOVE_OK);
}
/***********************************************************************************************
* AircraftClass::Good_Fire_Location -- Searches for and finds a good spot to fire from. *
* *
* Given the specified target, this routine will locate a good spot for the aircraft to *
* fire at the target. *
* *
* INPUT: target -- The target that is desired to be attacked. *
* *
* OUTPUT: Returns with the target location of the place that firing should be made from. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/12/1995 JLB : Created. *
* 06/14/1995 JLB : Finer resolution on ring scan. *
* 11/02/1996 JLB : Bias fire position to get closer to moving objects. *
*=============================================================================================*/
TARGET AircraftClass::Good_Fire_Location(TARGET target) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (Target_Legal(target)) {
int range = Weapon_Range(0);
COORDINATE tcoord = As_Coord(target);
CELL bestcell = 0;
CELL best2cell = 0;
int bestval = -1;
int best2val = -1;
/*
** Try to get closer to a target that is moving.
*/
COORDINATE altcoord = 0;
if (Is_Target_Object(target) && As_Object(target)->Is_Foot()) {
TARGET alttarg = ((FootClass *)As_Object(target))->NavCom;
if (Target_Legal(alttarg)) {
altcoord = As_Coord(alttarg);
}
}
for (int r = range-0x0100; r > 0x0100; r -= 0x0100) {
for (int face = 0; face < 255; face += 16) {
COORDINATE newcoord = Coord_Move(tcoord, (DirType)face, r);
CELL newcell = Coord_Cell(newcoord);
CELL actualcell = Coord_Cell(Coord_Sub(newcoord, XY_Coord(0, FLIGHT_LEVEL)));
//using function for IsVisible so we have different results for different players - JAS 2019/09/30
if (Map.In_Radar(actualcell) && (Session.Type != GAME_NORMAL || Map[newcell].Is_Visible(PlayerPtr)) && Cell_Seems_Ok(newcell, true)) {
int dist;
if (altcoord != 0) {
dist = ::Distance(newcoord, altcoord);
} else {
dist = Distance(newcoord);
}
if (bestval == -1 || dist < bestval) {
best2val = bestval;
best2cell = bestcell;
bestval = dist;
bestcell = newcell;
}
}
}
if (bestval != -1) break;
}
if (best2val == -1) {
best2cell = bestcell;
}
/*
** If it found a good firing location, then return this location as
** a target value.
*/
if (bestval != -1) {
if (Percent_Chance(50)) {
return(::As_Target(bestcell));
} else {
return(::As_Target(best2cell));
}
}
}
return(TARGET_NONE);
}
/***********************************************************************************************
* AircraftClass::Cell_Seems_Ok -- Checks to see if a cell is good to enter. *
* *
* This routine examines the navigation computers of other aircraft in order to see if the *
* specified cell is safe to fly to. The intent of this routine is to avoid unnecessary *
* mid-air collisions. *
* *
* INPUT: cell -- The cell to examine for clear airspace. *
* *
* strict -- Should the scan consider the aircraft, that is making this check, a *
* blocking aircraft. Typically, the aircraft itself is not considered *
* a blockage -- an aircraft can always exist where it is currently *
* located. A strict check is useful for helicopters that need to move *
* around at the slightest provocation. *
* *
* OUTPUT: Is the specified cell free from airspace conflicts? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
*=============================================================================================*/
bool AircraftClass::Cell_Seems_Ok(CELL cell, bool strict) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
/*
** Make sure that no other aircraft are heading to the selected location. If they
** are, then don't consider the location as valid.
*/
TARGET astarget = ::As_Target(cell);
for (int index = 0; index < Aircraft.Count(); index++) {
AircraftClass * air = Aircraft.Ptr(index);
if (air && (strict || air != this) && !air->IsInLimbo) {
if (Coord_Cell(air->Coord) == cell || air->NavCom == astarget) {
return(false);
}
}
}
return(true);
}
/***********************************************************************************************
* AircraftClass::Pip_Count -- Returns the number of "objects" in aircraft. *
* *
* This routine is used by the render logic to draw the little container "pips". This *
* corresponds to the number of passengers for a transport helicopter or the number of *
* shots remaining for an attack helicopter. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the number of "pips" to render on the aircraft. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/11/1995 JLB : Created. *
*=============================================================================================*/
int AircraftClass::Pip_Count(void) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
int retval = 0;
bool carrying_passengers = (Class->Max_Passengers() > 0) && ((*this != AIRCRAFT_BADGER) || (Mission != MISSION_HUNT));
if (carrying_passengers) {
retval = How_Many();
} else {
if (Ammo) {
retval = Class->Max_Pips() * fixed(Ammo, Class->MaxAmmo);
if (!retval) retval = 1;
}
}
return(retval);
}
/***********************************************************************************************
* AircraftClass::Mission_Enter -- Control aircraft to fly to the helipad or repair center. *
* *
* This routine is used when the aircraft needs to fly for either rearming or repairing. *
* It tries to establish contact with the support building. Once contact is established *
* the ground controller takes care of commanding the aircraft. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the delay before this routine should be called again. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/12/1995 JLB : Created. *
* 07/04/1995 JLB : Ground controller gives orders. *
*=============================================================================================*/
int AircraftClass::Mission_Enter(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
enum {
INITIAL,
TAKEOFF,
ALTITUDE,
STACK,
DOWNWIND,
CROSSWIND,
TRAVEL,
LANDING
};
/*
** Verify that it has a valid NavCom. If it doesn't then request one from the
** building this building is trying to land upon. If that fails, then enter
** idle mode.
*/
if (!Target_Legal(NavCom) && In_Which_Layer() != LAYER_GROUND) {
if (Transmit_Message(RADIO_DOCKING) != RADIO_ROGER) {
Enter_Idle_Mode();
return(1);
}
}
switch (Status) {
case INITIAL:
if (Height < FLIGHT_LEVEL || IsLanding) {
Status = TAKEOFF;
} else {
Status = ALTITUDE;
}
break;
case TAKEOFF:
if (Process_Take_Off()) {
/*
** After takeoff is complete, break radio contact with any helipad that this
** helicopter is taking off from.
*/
if (In_Radio_Contact() && Map[Coord].Cell_Building() == Contact_With_Whom()) {
Transmit_Message(RADIO_OVER_OUT);
}
Status = ALTITUDE;
}
break;
case ALTITUDE:
/*
** Establish radio contact with the building this helicopter is trying
** to land at.
*/
if (In_Radio_Contact()) {
if (!Target_Legal(NavCom)) {
Transmit_Message(RADIO_DOCKING);
if (!Target_Legal(NavCom)) {
Enter_Idle_Mode();
return(1);
}
}
Status = STACK;
} else {
TechnoClass * tech = As_Techno(NavCom);
if (tech && Transmit_Message(RADIO_CAN_LOAD, tech) == RADIO_ROGER) {
Transmit_Message(RADIO_HELLO, tech);
Transmit_Message(RADIO_DOCKING);
Status = STACK;
} else {
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if (tech->What_Am_I() != RTTI_VESSEL) {
Assign_Destination(TARGET_NONE);
Enter_Idle_Mode();
}
#else
Assign_Destination(TARGET_NONE);
Enter_Idle_Mode();
#endif
}
}
break;
case STACK:
if (Class->IsFixedWing) {
int distance;
TARGET togo;
BuildingClass const * building = As_Building(NavCom);
if (building) {
togo = ::As_Target(building->Check_Point(CHECK_STACK));
} else {
togo = NavCom;
}
distance = Process_Fly_To(true, togo);
if (distance < 0x0080) {
Status = DOWNWIND;
}
} else {
Status = DOWNWIND;
}
break;
case DOWNWIND:
if (Class->IsFixedWing) {
int distance;
TARGET togo;
Set_Speed(200);
BuildingClass const * building = As_Building(NavCom);
if (building) {
togo = ::As_Target(building->Check_Point(CHECK_DOWNWIND));
} else {
togo = NavCom;
}
distance = Process_Fly_To(true, togo);
if (distance < 0x0080) {
Status = CROSSWIND;
}
} else {
Status = CROSSWIND;
}
break;
case CROSSWIND:
if (Class->IsFixedWing) {
int distance;
TARGET togo;
Set_Speed(140);
BuildingClass const * building = As_Building(NavCom);
if (building) {
togo = ::As_Target(building->Check_Point(CHECK_CROSSWIND));
} else {
togo = NavCom;
}
distance = Process_Fly_To(true, togo);
if (distance < 0x0080) {
Status = TRAVEL;
}
} else {
Status = TRAVEL;
}
break;
case TRAVEL:
Transmit_Message(RADIO_DOCKING);
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if (!In_Radio_Contact() && !Is_Target_Vessel(NavCom)) {
#else
if (!In_Radio_Contact()) {
#endif
Assign_Destination(TARGET_NONE);
Enter_Idle_Mode();
} else {
int distance = Process_Fly_To(true, NavCom);
if (Class->IsFixedWing) {
if (distance < 0x0400) {
Status = LANDING;
}
return(1);
} else {
if (distance < 0x0080) {
if (Target_Legal(TarCom)) {
SecondaryFacing.Set_Desired(Direction(TarCom));
} else {
SecondaryFacing.Set_Desired(Pose_Dir());
}
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if (Is_Target_Vessel(NavCom) && !In_Radio_Contact()) {
Enter_Idle_Mode();
break;
}
#endif
if (distance < 0x0010) {
Status = LANDING;
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if(Is_Target_Vessel(NavCom) && As_Vessel(NavCom)->NavCom) {
Status = TRAVEL;
}
#endif
}
break;
} else {
SecondaryFacing.Set_Desired(Direction(NavCom));
// SecondaryFacing.Set_Desired(::Direction(Fire_Coord(0), As_Coord(NavCom)));
}
}
return(3);
}
break;
case LANDING:
if (IsTakingOff && !Class->IsFixedWing) {
Assign_Destination(TARGET_NONE);
Enter_Idle_Mode();
}
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
// If we were trying to land on a carrier and it moved, take off again
if ( As_Vessel(NavCom) && !In_Radio_Contact()) {
Status = INITIAL;
break;
}
#endif
if (Process_Landing()) {
switch (Transmit_Message(RADIO_IM_IN)) {
case RADIO_ROGER:
Assign_Mission(MISSION_GUARD);
break;
case RADIO_ATTACH:
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if(Contact_With_Whom()->What_Am_I() != RTTI_VESSEL) Limbo();
#else
Limbo();
#endif
Contact_With_Whom()->Attach(this);
break;
default:
Enter_Idle_Mode();
}
}
break;
default:
break;
}
return(1);
}
/***********************************************************************************************
* AircraftClass::Good_LZ -- Locates a good spot to land. *
* *
* This routine is used when helicopters need a place to land, but there are no obvious *
* spots (i.e., helipad) available. It will try to land near a friendly helipad or friendly *
* building if there are no helipads anywhere. In the event that there are no friendly *
* buildings anywhere on the map, then just land right where it is flying. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the target location where this aircraft should land. This value may *
* not be a clear cell, but the normal landing logic will resolve that problem. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/12/1995 JLB : Created. *
*=============================================================================================*/
TARGET AircraftClass::Good_LZ(void) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
/*
** Scan through all of the buildings and try to land near
** the helipad (if there is one) or the nearest friendly building.
*/
CELL bestcell = 0;
int bestdist = -1;
for (int index = 0; index < Buildings.Count(); index++) {
BuildingClass * building = Buildings.Ptr(index);
if (building && !building->IsInLimbo && building->House == House) {
int dist = Distance(building);
if (*building == Class->Building) {
dist /= 4;
}
if (bestdist == -1 || dist < bestdist) {
bestdist = dist;
bestcell = Coord_Cell(building->Center_Coord());
}
}
}
/*
** Return with the suitable location if one was found.
*/
if (bestdist != -1) {
return(::As_Target(bestcell));
}
/*
** No good location was found. Just try to land here.
*/
return(::As_Target(Coord_Cell(Coord)));
}
/***********************************************************************************************
* AircraftClass::Set_Speed -- Sets the speed for the aircraft. *
* *
* This routine will set the speed for the aircraft. The speed is specified as a fraction *
* of full speed. *
* *
* INPUT: speed -- The fixed point fractional speed setting. 0x00 is stopped, 0xFF is full *
* speed. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Set_Speed(int speed)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
FootClass::Set_Speed(speed);
MPHType sp = MPHType(min(Class->MaxSpeed * SpeedBias * House->AirspeedBias, MPH_LIGHT_SPEED));
Fly_Speed(speed, sp);
}
/***********************************************************************************************
* AircraftClass::Fire_Direction -- Determines the direction of fire. *
* *
* This routine will determine what direction a projectile would take if it were fired *
* from the aircraft. This is the direction that the aircraft's body is facing. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the direction of projectile fire. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/19/1995 JLB : Created. *
*=============================================================================================*/
DirType AircraftClass::Fire_Direction(void) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
return(SecondaryFacing.Current());
}
/***********************************************************************************************
* AircraftClass::~AircraftClass -- Destructor for aircraft object. *
* *
* This is the destructor for aircraft. It will limbo the aircraft if it isn't already *
* and also removes the aircraft from any team it may be attached to. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 06/24/1995 JLB : Created. *
*=============================================================================================*/
AircraftClass::~AircraftClass(void)
{
if (GameActive && Class) {
/*
** Remove this member from any team it may be associated with. This must occur at the
** top most level of the inheritance hierarchy because it may call virtual functions.
*/
if (Team) {
Team->Remove(this);
Team = NULL;
}
House->Tracking_Remove(this);
/*
** If there are any cargo members, delete them.
*/
while (Is_Something_Attached()) {
delete Detach_Object();
}
AircraftClass::Limbo();
Class = 0;
}
ID = -1;
}
/***********************************************************************************************
* AircraftClass::Scatter -- Causes the aircraft to move away a bit. *
* *
* This routine will cause the aircraft to move away from its current location and then *
* enter some idle mode. Typically this is called when the aircraft is attacked while on *
* the ground. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/08/1995 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Scatter(COORDINATE , bool, bool )
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
/*
** Certain missions prevent scattering regardless of whether it would be
** a good idea or not.
*/
if (!MissionControl[Mission].IsScatter) return;
/*
** Fixed wing aircraft never scatter.
*/
if (Class->IsFixedWing) return;
if (IsLanding || Height == 0) {
IsLanding = false;
IsTakingOff = true;
}
Enter_Idle_Mode();
}
/***********************************************************************************************
* AircraftClass::Mission_Guard -- Handles aircraft in guard mode. *
* *
* Aircraft don't like to be in guard mode if in flight. If this situation is detected, *
* then figure out what the aircraft should be doing and go do it. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the number of game frames to delay before calling this routine again. *
* *
* WARNINGS: This routine typically calls the normal guard logic for ground units. *
* *
* HISTORY: *
* 07/18/1995 JLB : Created. *
* 10/10/1995 JLB : Hunts for harvesters that are unescorted. *
*=============================================================================================*/
int AircraftClass::Mission_Guard(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (Height == FLIGHT_LEVEL) {
/*
** If part of a team, then do nothing, since the team
** handler will take care of giving this aircraft a
** mission.
*/
if (Team) {
if (Target_Legal(NavCom)) {
Assign_Mission(MISSION_MOVE);
}
return(MissionControl[Mission].Normal_Delay());
}
if (Class->PrimaryWeapon == NULL) {
Assign_Destination(::As_Target(Coord_Cell(Coord)));
Assign_Mission(MISSION_MOVE);
} else {
if (!Team.Is_Valid()) Enter_Idle_Mode();
}
return(1);
}
if (House->IsHuman) return(MissionControl[Mission].Normal_Delay());
/*
** If the aircraft is very badly damaged, then it will search for a
** repair bay first.
*/
if (House->Available_Money() >= 100 && Health_Ratio() <= Rule.ConditionYellow) {
if (!In_Radio_Contact() ||
(Height == 0 &&
(Contact_With_Whom()->What_Am_I() != RTTI_BUILDING || *((BuildingClass *)Contact_With_Whom()) != STRUCT_REPAIR))) {
BuildingClass * building = Find_Docking_Bay(STRUCT_REPAIR, true);
if (building != NULL) {
Assign_Destination(building->As_Target());
Assign_Target(TARGET_NONE);
Assign_Mission(MISSION_ENTER);
return(1);
}
}
}
/*
** If the aircraft cannot attack anything because of lack of ammo,
** abort any normal guard logic in order to look for a helipad
** to rearm.
*/
if (Ammo == 0 && Is_Weapon_Equipped()) {
if (!In_Radio_Contact()) {
BuildingClass * building = Find_Docking_Bay(STRUCT_HELIPAD, false);
#ifdef FIXIT_CARRIER // checked - ajw 9/28/98
if (!Class->IsFixedWing) {
int dist = 0x7FFFFFFF;
if (building) dist=Distance(building);
for (int index = 0; index < Vessels.Count(); index++) {
VesselClass *ship = Vessels.Ptr(index);
if (ship != NULL && *ship == VESSEL_CARRIER && !ship->IsInLimbo && ship->IsActive && ship->House == House && ship->How_Many() < ship->Class->Max_Passengers()) {
if (Distance(ship) < dist || !building) {
building = (BuildingClass *)ship;
dist = Distance(ship);
}
// break;
}
}
}
#endif
if (building != NULL) {
Assign_Destination(building->As_Target());
Assign_Target(TARGET_NONE);
Assign_Mission(MISSION_ENTER);
return(1);
}
}
}
/*
** If the aircraft already has a target, then attack it if possible.
*/
if (Target_Legal(TarCom)) {
Assign_Mission(MISSION_ATTACK);
return(1);
}
/*
** Transport helicopters don't really do anything but just sit there.
*/
if (!Is_Weapon_Equipped()) {
return(TICKS_PER_SECOND*3);
}
/*
** Computer controlled helicopters will defend themselves by bouncing around
** and looking for a free helipad.
*/
if (Height == 0 && !In_Radio_Contact()) {
Scatter(0, true);
return(TICKS_PER_SECOND*3);
}
/*
** Perform a special check to hunt for harvesters that are outside of the protective
** shield of their base.
*/
if (House->State != STATE_ATTACKED) {
TARGET target = House->Find_Juicy_Target(Coord);
if (Target_Legal(target)) {
Assign_Target(target);
Assign_Mission(MISSION_ATTACK);
}
}
return(FootClass::Mission_Guard());
}
/***********************************************************************************************
* AircraftClass::Mission_Guard_Area -- Handles the aircraft guard area logic. *
* *
* This routine handles area guard logic for aircraft. Aircraft require special handling *
* for this mode since they are to guard area only if they are in a position to do so. *
* Otherwise they just defend themselves. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the number of game frames to delay before calling this routine *
* again. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/10/1995 JLB : Created. *
*=============================================================================================*/
int AircraftClass::Mission_Guard_Area(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (Height == FLIGHT_LEVEL) {
if (!Team.Is_Valid()) Enter_Idle_Mode();
return(1);
}
if (House->IsHuman) return(TICKS_PER_SECOND);
if (Height == 0 && !In_Radio_Contact()) {
Scatter(0, true);
return(TICKS_PER_SECOND*3);
}
if (Target_Legal(TarCom)) {
Assign_Mission(MISSION_ATTACK);
return(1);
}
return(FootClass::Mission_Guard_Area());
}
/***********************************************************************************************
* AircraftClass::Response_Attack -- Gives audio response to attack order. *
* *
* This routine is used to give an audio response to an attack order. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/10/1995 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Response_Attack(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
static VocType _response[] = {
VOC_AFFIRM,
VOC_ACKNOWL
};
VocType response = _response[Sim_Random_Pick(0, ARRAY_SIZE(_response)-1)];
if (AllowVoice) {
Sound_Effect(response, fixed(1), -(ID+1));
}
}
/***********************************************************************************************
* AircraftClass::Response_Move -- Gives audio response to move request. *
* *
* This routine is used to give an audio response to movement orders. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/10/1995 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Response_Move(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
static VocType _response[] = {
VOC_ACKNOWL,
VOC_AFFIRM
};
VocType response = _response[Sim_Random_Pick(0, ARRAY_SIZE(_response)-1)];
if (AllowVoice) {
Sound_Effect(response, fixed(1), -(ID+1));
}
}
/***********************************************************************************************
* AircraftClass::Response_Select -- Gives audio response when selected. *
* *
* This routine is called when an audio response for selection is desired. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/10/1995 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Response_Select(void)
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
static VocType _response[] = {
VOC_VEHIC,
VOC_REPORT,
VOC_YESSIR,
VOC_YESSIR,
VOC_YESSIR,
VOC_AWAIT
};
VocType response = _response[Sim_Random_Pick(0, ARRAY_SIZE(_response)-1)];
if (AllowVoice) {
Sound_Effect(response, fixed(1), -(ID+1));
}
}
/***********************************************************************************************
* AircraftClass::Can_Fire -- Checks to see if the aircraft can fire. *
* *
* This routine is used to determine if the aircraft can fire its weapon at the target *
* specified. If it cannot, then the reason why is returned. *
* *
* INPUT: target -- The target that the aircraft might fire upon. *
* *
* which -- The weapon that will be used to fire. *
* *
* OUTPUT: Returns with the reason why it can't fire or with FIRE_OK. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/05/1996 JLB : Created. *
* 07/11/1996 JLB : Fixed for camera carrying aircraft. *
*=============================================================================================*/
FireErrorType AircraftClass::Can_Fire(TARGET target, int which) const
{
assert(Aircraft.ID(this) == ID);
assert(IsActive);
if (Passenger && !Is_Something_Attached()) {
return(FIRE_AMMO);
}
bool camera = (Class->PrimaryWeapon != NULL && Class->PrimaryWeapon->IsCamera);
bool fudge = (Passenger || (Class->PrimaryWeapon != NULL && Class->PrimaryWeapon->Bullet != NULL && Class->PrimaryWeapon->Bullet->IsParachuted));
if (fudge && !camera && !Ammo && !Passenger) {
return(FIRE_AMMO);
}
/*
** Passenger aircraft that wish to 'fire' actually are requesting to
** paradrop or 'throw out' the cargo. This is always allowed if the terrain under the
** aircraft is generally clear.
*/
if (camera || (fudge && Passenger && Is_Something_Attached())) {
if (Arm != 0) return(FIRE_REARM);
if (Distance(target) < (camera ? 0x0380 : 0x0200) && Map.In_Radar(Coord_Cell(Center_Coord()))) {
// if (Distance(target) < (camera ? 0x0380 : 0x0280) && Map.In_Radar(Coord_Cell(Center_Coord()))) {
return(FIRE_OK);
}
return(FIRE_RANGE);
}
FireErrorType canfire = FootClass::Can_Fire(target, which);
if (canfire == FIRE_OK) {
/*
** Double check to make sure that the facing is roughly toward
** the target. If the difference is too great, then firing is
** temporarily postponed.
*/
if (Class->IsFixedWing) {
int diff = PrimaryFacing.Difference(Direction(TarCom));
if (ABS(diff) > (fudge ? 16 : 8)) {
return(FIRE_FACING);
}
}
}
return(canfire);
}
/***********************************************************************************************
* AircraftClass::Landing_Takeoff_AI -- Handle aircraft take off and landing processing. *
* *
* This routine handles the tricky maneuver of taking off and landing. The process of *
* landing is not entirely safe and thus the aircraft may be destroyed as a consequence. *
* *
* INPUT: none *
* *
* OUTPUT: bool; Was the aircraft destroyed by this process? *
* *
* WARNINGS: Only call this routine once per aircraft per game logic loop. Be sure to *
* examine the return value and if true, abort all further processing of this *
* aircraft since it is now dead. *
* *
* HISTORY: *
* 07/29/1996 JLB : Created. *
*=============================================================================================*/
bool AircraftClass::Landing_Takeoff_AI(void)
{
/*
** Handle landing and taking off logic. Helicopters are prime users of this technique. The
** aircraft will either gain or lose altitude as appropriate. As the aircraft transitions
** between flying level and ground level, it will be moved into the appropriate render
** layer.
*/
if (Is_Door_Closed() && (IsLanding || IsTakingOff)) {
LayerType layer = In_Which_Layer();
if (IsLanding) {
Mark(MARK_UP);
if (Height) Height -= Pixel_To_Lepton(1);
if (Height <= 0) {
Height = 0;
IsLanding = false;
Set_Speed(0);
/*
** If the NavCom now equals the destination, then clear out the NavCom.
*/
if (Coord_Cell(Center_Coord()) == As_Cell(NavCom)) {
Assign_Destination(TARGET_NONE);
}
/*
** If a fixed-wing aircraft just landed on the ground, blow him up
*/
if (Class->IsFixedWing && Mission != MISSION_ENTER) {
Strength = 1;
int damage = Strength;
Map.Remove(this, layer);
Take_Damage(damage, 0, WARHEAD_AP, 0, true);
return(true);
}
if (Target_Legal(NavCom) && As_Techno(NavCom) == Contact_With_Whom()) {
if (In_Radio_Contact() && Transmit_Message(RADIO_IM_IN) != RADIO_ROGER) {
Scatter(0, true);
}
}
}
Mark(MARK_DOWN);
}
if (IsTakingOff) {
Mark(MARK_UP);
// Map.Remove(this, layer);
Height += Pixel_To_Lepton(1);
if (Height >= FLIGHT_LEVEL) {
Height = FLIGHT_LEVEL;
IsTakingOff = false;
}
// Map.Submit(this, In_Which_Layer());
Mark(MARK_DOWN);
}
/*
** Make adjustments for altitude by moving from one layer to another as
** necessary.
*/
if (layer != In_Which_Layer()) {
/*
** When the aircraft is about to enter the ground layer, perform on last
** check to see if it is legal to enter that location. If not, then
** start the take off process. Let the normal logic handle this
** change of plans.
*/
bool ok = true;
if (In_Which_Layer() == LAYER_GROUND && !IsTakingOff && !Class->IsFixedWing) {
if (!Is_LZ_Clear(::As_Target(Coord_Cell(Coord)))) {
IsTakingOff = true;
Mark(MARK_UP);
Height += Pixel_To_Lepton(1);
Mark(MARK_DOWN);
ok = false;
}
}
if (ok) {
Map.Remove(this, layer);
Map.Submit(this, In_Which_Layer());
/*
** When the aircraft is close to the ground, it should exist as a ground object.
** This aspect is controlled by the Place_Down and Pick_Up functions.
*/
if (In_Which_Layer() == LAYER_GROUND) {
Assign_Destination(TARGET_NONE); // Clear the navcom.
Transmit_Message(RADIO_TETHER);
Look();
// Map.Sight_From(Coord_Cell(Coord), 1, House, false);
} else {
Transmit_Message(RADIO_UNTETHER);
/*
** If the navigation computer is not attached to the object this
** aircraft is in radio contact with, then assume that radio
** contact is now superfluous. Break radio contact.
*/
if (In_Radio_Contact() && Target_Legal(NavCom) && NavCom != Contact_With_Whom()->As_Target()) {
Transmit_Message(RADIO_OVER_OUT);
}
}
}
}
}
return(false);
}
/***********************************************************************************************
* AircraftClass::Edge_Of_World_AI -- Detect if aircraft has exited the map. *
* *
* Certain aircraft will be eliminated when they leave the edge of the world presumably *
* after completing their mission. An exception is for aircraft that have been newly *
* created as reinforcements and have not yet completed their mission. *
* *
* INPUT: none *
* *
* OUTPUT: bool; Was the aircraft deleted by this routine? *
* *
* WARNINGS: Be sure to call this routine only once per aircraft per game logic loop. If *
* the return value is true, then abort any further processing of this aircraft *
* since it has been eliminated. *
* *
* HISTORY: *
* 07/29/1996 JLB : Created. *
*=============================================================================================*/
bool AircraftClass::Edge_Of_World_AI(void)
{
if (!Map.In_Radar(Coord_Cell(Coord))) {
if (Mission == MISSION_RETREAT /*|| (*this == AIRCRAFT_CARGO && !Is_Something_Attached())*/) {
/*
** Check to see if there are any civilians aboard. If so, then flag the house
** that the civilian evacuation trigger event has been fulfilled.
*/
while (Is_Something_Attached()) {
FootClass * obj = Detach_Object();
/*
** Flag the owning house that civ evacuation has occurred.
*/
if (_Counts_As_Civ_Evac(obj)) {
obj->House->IsCivEvacuated = true;
}
if (obj->Team.Is_Valid()) obj->Team->IsLeaveMap = true;
#ifdef OLD
/*
** Transport planes that leave can only be because they carry purchased
** equipment and must be have their cost refunded.
*/
if (*this == AIRCRAFT_CARGO) {
House->Refund_Money(obj->Class_Of().Cost_Of());
}
#endif
delete obj;
}
if (Team.Is_Valid()) {
Team->IsLeaveMap = true;
}
Stun();
delete this;
return(true);
}
} else {
IsLocked = true;
}
return(false);
}
/***********************************************************************************************
* AircraftClass::Movement_AI -- Handles aircraft physical movement logic. *
* *
* This routine manages the aircraft movement across the map. If any movement occurred, the *
* aircraft will be flagged to be redrawn. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: Only call this routine once per aircraft per game logic loop. *
* *
* HISTORY: *
* 07/29/1996 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Movement_AI(void)
{
/*
** If for some strange reason, there is a valid NavCom, but this aircraft is not
** in a movement order, then give it a movement order.
*/
if (Target_Legal(NavCom) && Mission == MISSION_GUARD && MissionQueue == MISSION_NONE) {
Assign_Mission(MISSION_MOVE);
}
if (Speed != 0) {
if (In_Which_Layer() == LAYER_GROUND) {
Mark(MARK_UP);
Physics(Coord, PrimaryFacing);
Mark(MARK_DOWN);
} else {
Mark(MARK_CHANGE_REDRAW);
if (Physics(Coord, PrimaryFacing) != RESULT_NONE) {
Mark(MARK_CHANGE_REDRAW);
}
}
}
}
/***********************************************************************************************
* AircraftClass::Rotation_AI -- Handle aircraft body and flight rotation. *
* *
* This will process the aircraft visible body and flight model rotation operations. If *
* any rotation occurred, the aircraft will be flagged to be redrawn. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: Only call this routine once per aircraft per game logic loop. *
* *
* HISTORY: *
* 07/29/1996 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Rotation_AI(void)
{
if (PrimaryFacing.Is_Rotating()) {
Mark(MARK_CHANGE_REDRAW);
if (PrimaryFacing.Rotation_Adjust(Class->ROT)) {
Mark(MARK_CHANGE_REDRAW);
}
}
if (Class->IsFixedWing) {
SecondaryFacing = PrimaryFacing;
}
if (SecondaryFacing.Is_Rotating()) {
Mark(MARK_CHANGE_REDRAW);
if (SecondaryFacing.Rotation_Adjust(Class->ROT)) {
Mark(MARK_CHANGE_REDRAW);
}
}
}
/***********************************************************************************************
* AircraftClass::Per_Cell_Process -- Handle the aircraft per cell process. *
* *
* This is a seldom used function since its only purpose is to be called when an aircraft *
* lands on the ground. *
* *
* INPUT: why -- Why was this per cell process function called. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/15/1996 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Per_Cell_Process(PCPType why)
{
BStart(BENCH_PCP);
FootClass::Per_Cell_Process(why);
BEnd(BENCH_PCP);
}
/***********************************************************************************************
* AircraftClass::Assign_Destination -- Assigns movement destination to the object. *
* *
* This routine is called when the object needs to have a new movement destination *
* assigned. Aircraft have their own version of this routine because a fixed-wing plane *
* trying to land will behave poorly if given a new destinatio while it's landing. * *
* *
* INPUT: destination -- The destination to assign to this object. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/24/1995 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Assign_Destination(TARGET dest)
{
assert(IsActive);
if (dest == NavCom) return;
if (Target_Legal(dest) && Class->IsFixedWing && (IsLanding || (Target_Legal(NavCom) && dest != NavCom))) {
// if (Target_Legal(dest) /*&& Class->IsFixedWing*/ && (IsLanding || (Target_Legal(NavCom) && dest != NavCom))) {
// if (Class->IsFixedWing || As_Cell(dest) != Coord_Cell(Center_Coord())) {
Process_Take_Off();
Status = 0;
// }
}
FootClass::Assign_Destination(dest);
}
/***********************************************************************************************
* AircraftClass::In_Which_Layer -- Calculates the display layer of the aircraft. *
* *
* This examines the aircraft to determine what display layer it should be located *
* in. Fixed wing aircraft must always be in the top layer if they are flying even though *
* they may be low to the ground. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the layer that this aircraft resides in. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/20/1996 JLB : Created. *
*=============================================================================================*/
LayerType AircraftClass::In_Which_Layer(void) const
{
if (Class->IsFixedWing && Height > 0) {
return(LAYER_TOP);
}
return(FootClass::In_Which_Layer());
}
/***********************************************************************************************
* AircraftClass::Look -- Aircraft will look if they are on the ground always. *
* *
* Aircraft perform a look operation according to their sight range. If the aircraft is *
* on the ground, then it will look a distance of one cell regardless of what its *
* specified sight range is. *
* *
* INPUT: incremental -- Is this an incremental look? *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/23/1996 JLB : Created. *
*=============================================================================================*/
void AircraftClass::Look(bool incremental)
{
assert(IsActive);
assert(!IsInLimbo);
int sight_range = Techno_Type_Class()->SightRange;
if (Height == 0) {
sight_range = 1;
}
if (sight_range) {
Map.Sight_From(Coord_Cell(Coord), sight_range, House, incremental);
}
}
unsigned AircraftClass::Spied_By() const
{
unsigned spiedby = FootClass::Spied_By();
/*
** Aircraft inherit the spied by flags of the helipad they've landed on
*/
BuildingClass* building = Map[Coord].Cell_Building();
if ((Height == 0) && In_Radio_Contact() && (building == Contact_With_Whom())) {
spiedby |= building->Spied_By();
}
return spiedby;
}
Reference in a new issue View git blame Copy permalink