// // 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/BULLET.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 : BULLET.CPP * * * * Programmer : Joe L. Bostic * * * * Start Date : April 23, 1994 * * * * Last Update : October 10, 1996 [JLB] * * * *---------------------------------------------------------------------------------------------* * Functions: * * BulletClass::AI -- Logic processing for bullet. * * BulletClass::BulletClass -- Bullet constructor. * * BulletClass::Bullet_Explodes -- Performs bullet explosion logic. * * BulletClass::Detach -- Removes specified target from this bullet's targeting system. * * BulletClass::Draw_It -- Displays the bullet at location specified. * * BulletClass::In_Which_Layer -- Fetches the layer that the bullet resides in. * * BulletClass::Init -- Clears the bullets array for scenario preparation. * * BulletClass::Is_Forced_To_Explode -- Checks if bullet should explode NOW. * * BulletClass::Mark -- Performs related map refreshing under bullet. * * BulletClass::Occupy_List -- Determines the bullet occupation list. * * BulletClass::Shape_Number -- Fetches the shape number for the bullet object. * * BulletClass::Sort_Y -- Sort coordinate for bullet rendering. * * BulletClass::Target_Coord -- Fetches coordinate to use when firing on this object. * * BulletClass::Unlimbo -- Transitions a bullet object into the game render/logic system. * * BulletClass::delete -- Bullet memory delete. * * BulletClass::new -- Allocates memory for bullet object. * * BulletClass::~BulletClass -- Destructor for bullet objects. * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ #include "function.h" /*********************************************************************************************** * BulletClass::BulletClass -- Bullet constructor. * * * * This is the constructor for the bullet class. It handles all * * initialization of the bullet and starting it in motion toward its * * target. * * * * INPUT: id -- The type of bullet this is (could be missile). * * * * OUTPUT: none * * * * WARNINGS: none * * * * HISTORY: * * 05/02/1994 JLB : Created. * * 06/20/1994 JLB : Firer is a base class pointer. * * 12/10/1994 JLB : Auto calculate range optional. * * 12/12/1994 JLB : Handles small arms as an instantaneous effect. * * 12/23/1994 JLB : Fixed scatter algorithm for non-homing projectiles. * * 12/31/1994 JLB : Removed range parameter (not needed). * *=============================================================================================*/ BulletClass::BulletClass(BulletType id, TARGET target, TechnoClass * payback, int strength, WarheadType warhead, int speed) : ObjectClass(RTTI_BULLET, Bullets.ID(this)), Class(BulletTypes.Ptr((int)id)), Payback(payback), PrimaryFacing(DIR_N), IsInaccurate(false), IsToAnimate(false), IsLocked(true), TarCom(target), MaxSpeed(speed), Warhead(warhead) { Strength = strength; Height = FLIGHT_LEVEL; } /*********************************************************************************************** * BulletClass::~BulletClass -- Destructor for bullet objects. * * * * The bullet destructor must detect if a dog has been attached to this bullet. If so, * * then the attached dog must be unlimboed back onto the map. This operation is necessary * * because, unlike other objects, the dog flies with the bullet it fires. * * * * INPUT: none * * * * OUTPUT: none * * * * WARNINGS: none * * * * HISTORY: * * 07/06/1996 JLB : Created. * *=============================================================================================*/ BulletClass::~BulletClass(void) { if (GameActive) { /* ** SPECIAL CASE: ** The dog is attached to the dog bullet in a limbo state. When the bullet is ** destroyed, the dog must come back out of limbo at the closest location possible to ** the bullet. */ if (Payback != NULL && Payback->What_Am_I() == RTTI_INFANTRY && ((InfantryClass *)Payback)->Class->IsDog) { InfantryClass * dog = (InfantryClass *)Payback; if (dog) { bool unlimbo = false; DirType dogface = dog->PrimaryFacing; COORDINATE newcoord = Coord; /* ** Ensure that the coordinate, that the dog is to appear at, is legal. If not, ** then find a nearby legal location. */ if (Can_Enter_Cell(newcoord) != MOVE_OK) { newcoord = Map.Nearby_Location(Coord_Cell(newcoord), dog->Class->Speed); } /* ** Try to put the dog down where the target impacted. If we can't ** put it in that cell, then scan through the adjacent cells, ** starting with our current heading, until we find a place where ** we can put him down. If all 8 adjacent cell checks fail, then ** just delete the dog. */ for (int i = -1; i < 8; i++) { if (i != -1) { newcoord = Adjacent_Cell(Coord, FacingType(i)); } ScenarioInit++; if (dog->Unlimbo(newcoord, dog->PrimaryFacing)) { dog->Mark(MARK_DOWN); dog->Do_Action(DO_DOG_MAUL, true); if (dog->WasSelected) { dog->Select(); } ScenarioInit--; unlimbo = true; break; } ScenarioInit--; } Payback = 0; if (!unlimbo) { delete dog; } } } BulletClass::Limbo(); } Class=0; Payback=0; } /*********************************************************************************************** * BulletClass::new -- Allocates memory for bullet object. * * * * This function will "allocate" a block of memory for a bullet object. * * This memory block is merely lifted from a fixed pool of blocks. * * * * INPUT: size -- The size of the memory block needed. * * * * OUTPUT: Returns with a pointer to an available bullet object block. * * * * WARNINGS: none * * * * HISTORY: * * 05/02/1994 JLB : Created. * *=============================================================================================*/ void * BulletClass::operator new(size_t ) { void * ptr = Bullets.Allocate(); if (ptr) { ((BulletClass *)ptr)->Set_Active(); } return(ptr); } /*********************************************************************************************** * BulletClass::delete -- Bullet memory delete. * * * * Since bullets memory is merely "allocated" out of a pool, it never * * actually gets deleted. * * * * INPUT: ptr -- Generic pointer to bullet object. * * * * OUTPUT: none * * * * WARNINGS: none * * * * HISTORY: * * 05/02/1994 JLB : Created. * *=============================================================================================*/ void BulletClass::operator delete(void * ptr) { if (ptr) { ((BulletClass *)ptr)->IsActive = false; } Bullets.Free((BulletClass *)ptr); } /*********************************************************************************************** * BulletClass::Occupy_List -- Determines the bullet occupation list. * * * * This function will determine the cell occupation list and return a pointer to it. Most * * bullets are small and the list is usually short, but on occasion, it can be a list that * * rivals the size of regular vehicles. * * * * INPUT: none * * * * OUTPUT: Returns with a pointer to the cell offset list that covers all the cells a bullet * * is over. * * * * WARNINGS: none * * * * HISTORY: * * 06/20/1994 JLB : Created. * * 01/05/1995 JLB : Handles projectiles with altitude. * *=============================================================================================*/ short const * BulletClass::Occupy_List(bool) const { assert(Bullets.ID(this) == ID); assert(IsActive); /* ** Super-gigundo units use the >= 64 coord spillage list logic. */ if (Class->IsGigundo) { static short _list[] = { -1, 0, 1, MAP_CELL_W*1-1, MAP_CELL_W*1, MAP_CELL_W*1+1, -MAP_CELL_W*1-1, -MAP_CELL_W*1, -MAP_CELL_W*1+1, MAP_CELL_W*2-1, MAP_CELL_W*2, MAP_CELL_W*2+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 }; return(_list); // return(Coord_Spillage_List(Coord, 64)); } /* ** Flying units need a special adjustment to the spillage list to take into account ** that the bullet imagery and the shadow are widely separated. */ if (Height > 0) { static short _list[25]; const short * ptr = Coord_Spillage_List(Coord, 5); int index = 0; CELL cell1 = Coord_Cell(Coord); while (ptr[index] != REFRESH_EOL) { _list[index] = ptr[index]; index++; } COORDINATE coord = Coord_Move(Coord, DIR_N, Height); CELL cell2 = Coord_Cell(coord); ptr = Coord_Spillage_List(coord, 5); while (*ptr != REFRESH_EOL) { _list[index++] = *ptr + (cell2 - cell1); ptr++; } _list[index] = REFRESH_EOL; return(_list); } return(Coord_Spillage_List(Coord, 10)); } /*********************************************************************************************** * BulletClass::Mark -- Performs related map refreshing under bullet. * * * * This routine marks the objects under the bullet so that they will * * be redrawn. This is necessary as the bullet moves -- objects under * * its path need to be restored. * * * * INPUT: none * * * * OUTPUT: none * * * * WARNINGS: none * * * * HISTORY: * * 05/02/1994 JLB : Created. * *=============================================================================================*/ bool BulletClass::Mark(MarkType mark) { assert(Bullets.ID(this) == ID); assert(IsActive); if (ObjectClass::Mark(mark)) { if (!Class->IsInvisible) { Map.Refresh_Cells(Coord_Cell(Coord), Occupy_List()); } return(true); } return(false); } /*********************************************************************************************** * BulletClass::AI -- Logic processing for bullet. * * * * This routine will perform all logic (flight) logic on the bullet. * * Primarily this is motion, fuse tracking, and detonation logic. Call * * this routine no more than once per bullet per game tick. * * * * INPUT: none * * * * OUTPUT: none * * * * WARNINGS: none * * * * HISTORY: * * 05/02/1994 JLB : Created. * *=============================================================================================*/ void BulletClass::AI(void) { assert(Bullets.ID(this) == ID); assert(IsActive); COORDINATE coord; ObjectClass::AI(); if (!IsActive) return; /* ** Ballistic objects are handled here. */ bool forced = false; // Forced explosion. if ((Class->IsArcing || Class->IsDropping) && !IsFalling) { forced = true; } /* ** Homing projectiles constantly change facing to face toward the target but ** they only do so every other game frame (improves game speed and makes ** missiles not so deadly). */ if ((Frame & 0x01) && Class->ROT != 0 && Target_Legal(TarCom)) { PrimaryFacing.Set_Desired(Direction256(Coord, ::As_Coord(TarCom))); } /* ** Move the projectile forward according to its speed ** and direction. */ coord = Coord; if (Class->IsFlameEquipped) { if (IsToAnimate) { if (stricmp(Class->GraphicName, "FB1") == 0) { new AnimClass(ANIM_FBALL_FADE, coord, 1); } else { new AnimClass(ANIM_SMOKE_PUFF, coord, 1); } } IsToAnimate = !IsToAnimate; } /* ** Handle any body rotation at this time. This process must ** occur every game fame in order to achieve smooth rotation. */ if (PrimaryFacing.Is_Rotating()) { PrimaryFacing.Rotation_Adjust(Class->ROT); } switch (Physics(coord, PrimaryFacing)) { /* ** When a projectile reaches the edge of the world, it ** vanishes from existence -- presumed to explode off ** map. */ case IMPACT_EDGE: Mark(); if (Payback != NULL && Class->Type == BULLET_GPS_SATELLITE) { bool reveal = false; if (Session.Type != GAME_GLYPHX_MULTIPLAYER) { if (Payback->House == PlayerPtr) { reveal = true; } } else { if (Payback->House->IsHuman) { reveal = true; } } if (reveal) { if (!Map.Is_Radar_Active()) { Map.Radar_Activate(1); } for (CELL cell = 0; cell < MAP_CELL_TOTAL; cell++) { Map.Map_Cell(cell, Payback->House); } Map.RadarClass::Flag_To_Redraw(true); } Payback->House->IsGPSActive = true; Payback->House->IsVisionary = true; } #ifdef OBSOLETE /* ** Hack: If it's the artificial nukes, don't let the bullets come down (as ** they're the only ones that blow up). We know it's artificial if you're ** at tech level 10 or below, because you can't build the nuclear silo until ** tech level 15 or so. */ if (Payback != NULL && Class->Type == BULLET_NUKE_UP && Payback->House->Control.TechLevel <= 10) { BulletClass * bullet = new BulletClass(BULLET_NUKE_DOWN, ::As_Target(Payback->House->NukeDest), Payback, 200, WARHEAD_NUKE, MPH_VERY_FAST); if (bullet) { int celly = Cell_Y(Payback->House->NukeDest); celly -= 15; if (celly < 1) celly = 1; COORDINATE start = Cell_Coord(XY_Cell(Cell_X(Payback->House->NukeDest), celly)); if (!bullet->Unlimbo(start, DIR_S)) { delete bullet; } } } #endif delete this; break; default: case IMPACT_NONE: /* ** The projectile has moved. Check its fuse. If detonation ** is signaled, then do so. Otherwise, just move. */ case IMPACT_NORMAL: Mark(); // if(Class->Type == BULLET_NUKE_DOWN) { // Render(true); // } if (Class->Type == BULLET_NUKE_UP) { if (Payback != NULL) { if (Distance(Payback->As_Target()) > 0x0C00) { delete this; return; } } } Coord = coord; /* ** See if the bullet should be forced to explode now in spite of what ** the fuse would otherwise indicate. Maybe the bullet hit a wall? */ if (!forced) { forced = Is_Forced_To_Explode(Coord); } /* ** If the bullet is not to explode, then perform normal flight ** maintenance (usually nothing). Otherwise, explode and then ** delete the bullet. */ if (!forced && (Class->IsDropping || !Fuse_Checkup(Coord))) { /* ** Certain projectiles lose strength when they travel. */ if (Class->IsDegenerate && Strength > 5) { Strength--; } } else { Bullet_Explodes(forced); delete this; } break; } } /*********************************************************************************************** * BulletClass::Shape_Number -- Fetches the shape number for the bullet object. * * * * Use this routine to fetch a shape number to use for this bullet object. * * * * INPUT: none * * * * OUTPUT: Returns with the shape number to use when drawing this bullet. * * * * WARNINGS: none * * * * HISTORY: * * 08/06/1996 JLB : Created. * *=============================================================================================*/ int BulletClass::Shape_Number(void) const { int shapenum = 0; if (!Class->IsFaceless) { shapenum = UnitClass::BodyShape[Dir_To_32(PrimaryFacing)]; } /* ** For tumbling projectiles, fetch offset stage. */ if (Class->Tumble > 0) { shapenum += (long)Frame % Class->Tumble; } return(shapenum); } /*********************************************************************************************** * BulletClass::Draw_It -- Displays the bullet at location specified. * * * * This routine displays the bullet visual at the location specified. * * * * INPUT: x,y -- The center coordinate to render the bullet at. * * * * window -- The window to clip to. * * * * OUTPUT: none * * * * WARNINGS: none * * * * HISTORY: * * 06/20/1994 JLB : Created. * * 06/27/1994 JLB : Takes a window clipping parameter. * * 01/08/1995 JLB : Handles translucent colors if necessary. * *=============================================================================================*/ void BulletClass::Draw_It(int x, int y, WindowNumberType window) const { assert(Bullets.ID(this) == ID); assert(IsActive); /* ** Certain projectiles aren't visible. This includes small bullets (which are actually ** invisible) and flame thrower flames (which are rendered as an animation instead of a projectile). */ if (Class->IsInvisible) return; /* ** If there is no shape loaded for this object, then ** it obviously can't be rendered -- just bail. */ void const * shapeptr = Get_Image_Data(); if (shapeptr == NULL) return; /* ** Get the basic shape number for this projectile. */ int shapenum = Shape_Number(); /* ** For flying projectiles, draw the shadow and adjust the actual projectile body ** render position. */ if (Height > 0 && Class->IsShadow) { if (Class->IsParachuted) { // Add 'this' parameter to call new shape draw intercept. ST - 5/22/2019 CC_Draw_Shape(this, AnimTypeClass::As_Reference(ANIM_PARA_BOMB).Get_Image_Data(), 1, x+Lepton_To_Pixel(Height/2), y+10, window, SHAPE_PREDATOR|SHAPE_CENTER|SHAPE_WIN_REL|SHAPE_FADING, NULL, DisplayClass::UnitShadow); } else { // Add 'this' parameter to call new shape draw intercept. ST - 5/22/2019 CC_Draw_Shape(this, shapeptr, shapenum, x, y, window, SHAPE_PREDATOR|SHAPE_CENTER|SHAPE_WIN_REL|SHAPE_FADING, NULL, DisplayClass::UnitShadow); } y -= Lepton_To_Pixel(Height); } /* ** Draw the main body of the projectile. */ ShapeFlags_Type flags = SHAPE_NORMAL; if (Class->IsTranslucent) { flags = SHAPE_GHOST; } if (Class->IsSubSurface) { // Add 'this' parameter to call new shape draw intercept. ST - 5/22/2019 CC_Draw_Shape(this, shapeptr, shapenum, x, y, window, flags|SHAPE_PREDATOR|SHAPE_CENTER|SHAPE_WIN_REL|SHAPE_FADING, NULL, DisplayClass::FadingShade); } else { // Add 'this' parameter to call new shape draw intercept. ST - 5/22/2019 CC_Draw_Shape(this, shapeptr, shapenum, x, y, window, flags|SHAPE_CENTER|SHAPE_WIN_REL, NULL, DisplayClass::UnitShadow); } } /*********************************************************************************************** * BulletClass::Init -- Clears the bullets array for scenario preparation. * * * * This routine will zero out the bullet tracking list and object array in preparation for * * the start of a new scenario. All bullets cease to exists after this function is * * called. * * * * INPUT: none * * * * OUTPUT: none * * * * WARNINGS: none * * * * HISTORY: * * 08/15/1994 JLB : Created. * *=============================================================================================*/ void BulletClass::Init(void) { Bullets.Free_All(); } /*********************************************************************************************** * BulletClass::Detach -- Removes specified target from this bullet's targeting system. * * * * When an object is removed from the game system, it must be removed all targeting and * * tracking systems as well. This routine is used to remove the specified object from the * * bullet. If the object isn't part of this bullet's tracking system, then no action is * * performed. * * * * INPUT: target -- The target to remove from this tracking system. * * * * all -- Is the target going away for good as opposed to just cloaking/hiding? * * * * OUTPUT: none * * * * WARNINGS: none * * * * HISTORY: * * 09/24/1994 JLB : Created. * *=============================================================================================*/ void BulletClass::Detach(TARGET target, bool all) { assert(Bullets.ID(this) == ID); assert(IsActive); ObjectClass * obj = As_Object(target); if (Payback != NULL && obj == Payback) { /* ** If we're being called as a result of the dog that fired us being put ** in limbo, then don't detach. If for any other reason, detach. */ if (Payback->What_Am_I() != RTTI_INFANTRY || !((InfantryClass *)Payback)->Class->IsDog) { Payback = 0; } } if (all && target == TarCom) { TarCom = TARGET_NONE; } } /*********************************************************************************************** * BulletClass::Unlimbo -- Transitions a bullet object into the game render/logic system. * * * * This routine is used to take a bullet object that is in limbo and transition it to the * * game system. A bullet object so transitioned, will be drawn and logic processing * * performed. In effect, it comes into existence. * * * * INPUT: coord -- The location where the bullet object is to appear. * * * * dir -- The initial facing for the bullet object. * * * * OUTPUT: bool; Was the unlimbo successful? * * * * WARNINGS: none * * * * HISTORY: * * 01/10/1995 JLB : Created. * *=============================================================================================*/ bool BulletClass::Unlimbo(COORDINATE coord, DirType dir) { assert(Bullets.ID(this) == ID); assert(IsActive); /* ** Try to unlimbo the bullet as far as the base class is concerned. Use the already ** set direction and strength if the "punt" values were passed in. This allows a bullet ** to be setup prior to being launched. */ if (!Class->IsHigh) { Height = 0; } if (ObjectClass::Unlimbo(coord)) { Map.Remove(this, In_Which_Layer()); COORDINATE tcoord = As_Coord(TarCom); /* ** Homing projectiles (missiles) do NOT override facing. They just fire in the ** direction specified and let the chips fall where they may. */ if (Class->ROT == 0 && !Class->IsDropping) { dir = Direction(tcoord); } /* ** Possibly adjust the target if this projectile is inaccurate. This occurs whenever ** certain weapons are trained upon targets they were never designed to attack. Example: when ** turrets or anti-tank missiles are fired at infantry. Indirect ** fire is inherently inaccurate. */ if (IsInaccurate || Class->IsInaccurate || ((Is_Target_Cell(TarCom) || Is_Target_Infantry(TarCom)) && (Warhead == WARHEAD_AP || Class->IsFueled))) { /* ** Inaccuracy for low velocity or homing projectiles manifests itself as a standard ** Circular Error of Probability (CEP) algorithm. High speed projectiles usually ** just overshoot the target by extending the straight line flight. */ if (/*Class->ROT != 0 ||*/ Class->IsArcing) { int scatterdist = (::Distance(coord, tcoord)/16)-0x0040; scatterdist = min(scatterdist, Rule.HomingScatter); scatterdist = max(scatterdist, 0); dir = (DirType)((dir + (Random_Pick(0, 10)-5)) & 0x00FF); tcoord = Coord_Scatter(tcoord, Random_Pick(0, scatterdist)); } else { int scatterdist = (::Distance(coord, tcoord)/16)-0x0040; scatterdist = min(scatterdist, Rule.BallisticScatter); scatterdist = max(scatterdist, 0); tcoord = Coord_Move(tcoord, dir, Random_Pick(0, scatterdist)); } } /* ** For very fast and invisible projectiles, just make the projectile exist at the target ** location and dispense with the actual flight. */ if (MaxSpeed == MPH_LIGHT_SPEED && Class->IsInvisible) { Coord = tcoord; } /* ** Set the range equal to either the class defined range or the calculated ** number of game frames it would take for the projectile to reach the target. */ int range = 0xFF; if (!Class->IsDropping) { range = (::Distance(tcoord, Coord) / MaxSpeed) + 4; } /* ** Projectile speed is usually the default value for that projectile, but ** certain projectiles alter speed according to the distance to the ** target. */ int speed = MaxSpeed; if (speed == MPH_LIGHT_SPEED) speed = MPH_IMMOBILE; if (Class->IsArcing) { speed = MaxSpeed + (Distance(tcoord) / 32); /* ** Set minimum speed (i.e., distance) for arcing projectiles. */ speed = max(speed, 25); } if (!Class->IsDropping) { Fly_Speed(255, (MPHType)speed); } /* ** Arm the fuse. */ Arm_Fuse(Coord, tcoord, range, ((As_Aircraft(TarCom)!=0) ? 0 : Class->Arming)); /* ** Projectiles that make a ballistic flight to impact point must determine a ** vertical component for the projectile launch. This is crudely simulated ** by biasing ground speed according to target distance and then giving ** enough vertical velocity to keep the projectile airborne for the ** desired amount of time. The mathematically correct solution would be to ** calculate launch angle (given fixed projectile velocity) and then derive ** the vertical and horizontal components. That solution would require a ** square root and an arcsine lookup table. OUCH! */ Riser = 0; if (Class->IsArcing) { IsFalling = true; Height = 1; Riser = ((Distance(tcoord)/2) / (speed+1)) * Rule.Gravity; Riser = max(Riser, 10); } if (Class->IsDropping) { IsFalling = true; Height = FLIGHT_LEVEL; // Height = Pixel_To_Lepton(24); Riser = 0; if (Class->IsParachuted) { AnimClass * anim = new AnimClass(ANIM_PARA_BOMB, Target_Coord()); // AnimClass * anim = new AnimClass(ANIM_PARACHUTE, Target_Coord()); if (anim) { anim->Attach_To(this); } } } Map.Submit(this, In_Which_Layer()); PrimaryFacing = dir; return(true); } return(false); } /*********************************************************************************************** * BulletClass::Target_Coord -- Fetches coordinate to use when firing on this object. * * * * * * INPUT: none * * * * OUTPUT: Returns with the coordinate that should be used when firing at the object. * * * * WARNINGS: none * * * * HISTORY: * * 09/21/1995 JLB : Created. * *=============================================================================================*/ COORDINATE BulletClass::Target_Coord(void) const { assert(Bullets.ID(this) == ID); assert(IsActive); return(Coord_Add(XY_Coord(0, -Height), Coord)); } /*********************************************************************************************** * BulletClass::Sort_Y -- Sort coordinate for bullet rendering. * * * * This will return the coordinate to use when sorting this bullet in the display list. * * Typically, this only occurs for bullets in the ground layer. Since bullets are to be * * seen a bit more than the normal sorting order would otherwise imply, bias the sort * * value such that bullets will tend to be drawn on top of the objects. * * * * INPUT: none * * * * OUTPUT: Returns with the coordinate to use when sorting this bullet in the display list. * * * * WARNINGS: none * * * * HISTORY: * * 10/02/1996 JLB : Created. * *=============================================================================================*/ COORDINATE BulletClass::Sort_Y(void) const { assert(this != 0); assert(IsActive); return(Coord_Move(Coord, DIR_S, CELL_LEPTON_H/2)); } /*********************************************************************************************** * BulletClass::In_Which_Layer -- Fetches the layer that the bullet resides in. * * * * This examines the bullet to determine what rendering layer it should be in. The * * normal logic applies unless this is a torpedo. A torpedo is always in the surface * * layer. * * * * INPUT: none * * * * OUTPUT: Returns with the render layer that this bullet should reside in. * * * * WARNINGS: none * * * * HISTORY: * * 10/10/1996 JLB : Created. * *=============================================================================================*/ LayerType BulletClass::In_Which_Layer(void) const { if (Class->IsSubSurface) { return(LAYER_SURFACE); } return(ObjectClass::In_Which_Layer()); } /*********************************************************************************************** * BulletClass::Is_Forced_To_Explode -- Checks if bullet should explode NOW. * * * * This routine will examine the bullet and where it is travelling in order to determine * * if it should prematurely explode. Typical of this would be when a bullet hits a wall * * or a torpedo hits a ship -- regardless of where the projectile was originally aimed. * * * * INPUT: coord -- The new coordinate to place the bullet at presuming it is forced to * * explode and a modification of the bullet's coordinate is needed. * * Otherwise, the coordinate is not modified. * * * * OUTPUT: bool; Should the bullet explode now? * * * * WARNINGS: none * * * * HISTORY: * * 10/10/1996 JLB : Created. * *=============================================================================================*/ bool BulletClass::Is_Forced_To_Explode(COORDINATE & coord) const { coord = Coord; CellClass const * cellptr = &Map[coord]; /* ** Check for impact on a wall or other high obstacle. */ if (!Class->IsHigh && cellptr->Overlay != OVERLAY_NONE && OverlayTypeClass::As_Reference(cellptr->Overlay).IsHigh) { coord = Cell_Coord(Coord_Cell(coord)); return(true); } /* ** Check to make sure that underwater projectiles (torpedoes) will not ** travel in anything but water. */ if (Class->IsSubSurface) { int d = ::Distance(Coord_Fraction(coord), XY_Coord(CELL_LEPTON_W/2, CELL_LEPTON_W/2)); if (cellptr->Land_Type() != LAND_WATER || (d < CELL_LEPTON_W/3 && cellptr->Cell_Techno() != NULL && cellptr->Cell_Techno() != Payback)) { /* ** Force explosion to be at center of techno object if one is present. */ if (cellptr->Cell_Techno() != NULL) { coord = cellptr->Cell_Techno()->Target_Coord(); } /* ** However, if the torpedo was blocked by a bridge, then force the ** torpedo to explode on top of that bridge cell. */ if (cellptr->Is_Bridge_Here()) { coord = Coord_Snap(coord); } return(true); } } /* ** Bullets are generally more effective when they are fired at aircraft. */ if (Class->IsAntiAircraft && As_Aircraft(TarCom) && Distance(TarCom) < 0x0080) { return(true); } /* ** No reason for forced explosion was detected, so return 'false' to ** indicate that no forced explosion is required. */ return(false); } /*********************************************************************************************** * BulletClass::Bullet_Explodes -- Performs bullet explosion logic. * * * * This handles the exploding bullet action. It will generate the animation and the * * damage as necessary. * * * * INPUT: none * * * * OUTPUT: none * * * * WARNINGS: The bullet should be deleted after this routine is called. * * * * HISTORY: * * 10/10/1996 JLB : Created. * *=============================================================================================*/ void BulletClass::Bullet_Explodes(bool forced) { /* ** When the target is reached, explode and do the damage ** required of it. For homing objects, don't force the explosion to ** match the target position. Non-homing projectiles adjust position so ** that they hit the target. This compensates for the error in line of ** flight logic. */ if ( (Payback != NULL && Payback->What_Am_I() == RTTI_INFANTRY && ((InfantryClass *)Payback)->Class->IsDog) || (!forced && !Class->IsArcing && Class->ROT == 0 && Fuse_Target())) { Coord = Fuse_Target(); } /* ** Non-aircraft targets apply damage to the ground. */ if (!Is_Target_Aircraft(TarCom) || As_Aircraft(TarCom)->In_Which_Layer() == LAYER_GROUND) { Explosion_Damage(Coord, Strength, Payback, Warhead); if (!IsActive) return; } else { /* ** Special damage apply for SAM missiles. This is the only way that missile ** damage affects the aircraft target. */ if (Distance(TarCom) < 0x0080) { AircraftClass * object = As_Aircraft(TarCom); int str = Strength; if (object) object->Take_Damage(str, 0, Warhead, Payback); } } /* ** For projectiles that are invisible while travelling toward the target, ** allow scatter effect for the impact animation. */ if (Class->IsInvisible) { Coord = Coord_Scatter(Coord, 0x0020); } /* ** Fetch the land type that the explosion will be upon. Special case for ** flying aircraft targets, their land type will be LAND_NONE. */ CellClass const * cellptr = &Map[Coord]; LandType land = cellptr->Land_Type(); if (Is_Target_Aircraft(TarCom) && As_Aircraft(TarCom)->In_Which_Layer() == LAYER_TOP) { land = LAND_NONE; } AnimType anim = Combat_Anim(Strength, Warhead, land); /* ** If it's a water explosion that's going to play, don't play it ** if its cell is the same as the center cell of the target ship. */ if (anim >= ANIM_WATER_EXP1 && anim <= ANIM_WATER_EXP3 && Is_Target_Vessel(TarCom)) { if (Coord_Cell(Coord) == Coord_Cell(As_Vessel(TarCom)->Center_Coord())) { anim = (AnimType) (ANIM_VEH_HIT1 + (anim - ANIM_WATER_EXP1)); } } if (anim != ANIM_NONE) { AnimClass * aptr = new AnimClass(anim, Coord); if (aptr) { aptr->Sort_Above(TarCom); } /* ** Special case trap: if they're making the nuclear explosion, ** and no anim is available, force the nuclear damage anyway ** because nuke damage is done in the middle of the animation ** and if there's no animation, there won't be any damage. */ if (!aptr && anim == ANIM_ATOM_BLAST) { GlyphX_Debug_Print("FAILED to create ANIM_ATOM_BLAST"); HousesType house = HOUSE_NONE; if (Payback) { house = Payback->House->Class->House; } AnimClass::Do_Atom_Damage(house, Coord_Cell(Coord)); } // MBL 05.20.2020 // Fix for Nuke or Atom Bomb killing structures and units during animation sequence and not getting kills tracked // Per https://jaas.ea.com/browse/TDRA-6610 // else if (aptr && anim == ANIM_ATOM_BLAST && aptr->OwnerHouse == HOUSE_NONE) { if (Payback && Payback->House && Payback->House->Class) { aptr->Set_Owner(Payback->House->Class->House); } } } // if (Payback && Payback->House == PlayerPtr && stricmp(Class->Name(), "GPSSATELLITE") == 0) { if (Payback && Class->Type == BULLET_GPS_SATELLITE) { bool reveal = false; if (Session.Type != GAME_GLYPHX_MULTIPLAYER) { if (Payback->House == PlayerPtr) { reveal = true; } } else { if (Payback->House->IsHuman) { reveal = true; } } if (reveal) { if (!Map.Is_Radar_Active()) { Map.Radar_Activate(1); } for (CELL cell = 0; cell < MAP_CELL_TOTAL; cell++) { Map.Map_Cell(cell, Payback->House); } Map.RadarClass::Flag_To_Redraw(true); } // Sound_Effect(VOC_SATTACT2); Payback->House->IsGPSActive = true; Payback->House->IsVisionary = true; } }