Zero Hour rebuilt from EA's source: x64, Direct3D 11, VS2022/CMake, ~60 original bugs fixed, an AI that builds a base. Bring your own game.
C++ cmakecnccommand-and-conquercppdirectx11game-enginegame-preservationgeneralsrtssage-enginex64zero-hour
/*
** Command & Conquer Generals Zero Hour(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program 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.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// Modified 2025-2026 by Olcay Seygan for Zero Hour Reforged; see the git history.
// Modified 2026 by İlyas Akın for the macOS/Linux port; see NOTICE.md and the git history.
////////////////////////////////////////////////////////////////////////////////
// //
// (c) 2001-2003 Electronic Arts Inc. //
// //
////////////////////////////////////////////////////////////////////////////////
// FILE: SpectreGunshipUpdate.cpp //////////////////////////////////////////////////////////////////////////
// Author: Mark Lorenzen, April 2003
// Desc: Update module to handle weapon firing of the SpectreGunship Generals special power.
///////////////////////////////////////////////////////////////////////////////////////////////////
#include "PreRTS.h" // This must go first in EVERY cpp file int the GameEngine
#define DEFINE_DEATH_NAMES
// INCLUDES ///////////////////////////////////////////////////////////////////////////////////////
#include "Common/GameAudio.h"
#include "Common/ThingTemplate.h"
#include "Common/ThingFactory.h"
#include "Common/Player.h"
#include "Common/PlayerList.h"
#include "Common/Xfer.h"
#include "Common/ClientUpdateModule.h"
#include "GameClient/ControlBar.h"
#include "GameClient/GameClient.h"
#include "GameClient/Drawable.h"
#include "GameClient/ParticleSys.h"
#include "GameClient/FXList.h"
#include "GameClient/ParticleSys.h"
#include "GameLogic/Locomotor.h"
#include "GameLogic/GameLogic.h"
#include "GameLogic/PartitionManager.h"
#include "GameLogic/Object.h"
#include "GameLogic/ObjectIter.h"
#include "GameLogic/WeaponSet.h"
#include "GameLogic/Weapon.h"
#include "GameLogic/TerrainLogic.h"
#include "GameLogic/Module/SpecialPowerModule.h"
#include "GameLogic/Module/SpectreGunshipUpdate.h"
#include "GameLogic/Module/PhysicsUpdate.h"
#include "GameLogic/Module/LaserUpdate.h"
#include "GameLogic/Module/ActiveBody.h"
#include "GameLogic/Module/AIUpdate.h"
#include "GameLogic/Module/ContainModule.h"
#ifdef _INTERNAL
// for occasional debugging...
//#pragma optimize("", off)
//#pragma MESSAGE("************************************** WARNING, optimization disabled for debugging purposes")
#endif
#define ORBIT_INSERTION_SLOPE_MAX (0.8f)
#define ORBIT_INSERTION_SLOPE_MIN (0.5f)
#define ONE (1.0f)
#define ZERO (0.0f)
#define LOTS_OF_SHOTS (9999)
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
SpectreGunshipUpdateModuleData::SpectreGunshipUpdateModuleData()
{
m_specialPowerTemplate = NULL;
/******BOTH*******//*BOTH*//******BOTH*******//******BOTH*******/ m_attackAreaRadius = 200.0f;
/*************/ m_gattlingStrafeFXParticleSystem = NULL;
/*************/ m_howitzerWeaponTemplate = NULL;
/*************/ m_orbitFrames = 0;
/*************/ m_targetingReticleRadius = 25.0f;
/*************/ m_gunshipOrbitRadius = 250.0f;
m_strafingIncrement = ConvertRetailPerFrameRate( 20.0f );
m_orbitInsertionSlope = 0.7f;
m_howitzerFiringRate = ConvertRetailFrames( 10 );
m_howitzerFollowLag = 0;
m_randomOffsetForHowitzer = 20.0f;
}
static Real zero = 0.0f;
//-------------------------------------------------------------------------------------------------
/*static*/ void SpectreGunshipUpdateModuleData::buildFieldParse(MultiIniFieldParse& p)
{
ModuleData::buildFieldParse(p);
static const FieldParse dataFieldParse[] =
{
{ "SpecialPowerTemplate", INI::parseSpecialPowerTemplate, NULL, offsetof( SpectreGunshipUpdateModuleData, m_specialPowerTemplate ) },
{ "GattlingTemplateName", INI::parseAsciiString, NULL, offsetof( SpectreGunshipUpdateModuleData, m_gattlingTemplateName ) },
{ "HowitzerFiringRate", INI::parseDurationUnsignedInt, NULL, offsetof( SpectreGunshipUpdateModuleData, m_howitzerFiringRate ) },
{ "OrbitTime", INI::parseDurationUnsignedInt, NULL, offsetof( SpectreGunshipUpdateModuleData, m_orbitFrames ) },
{ "HowitzerFollowLag", INI::parseDurationUnsignedInt, NULL, offsetof( SpectreGunshipUpdateModuleData, m_howitzerFollowLag ) },
{ "AttackAreaRadius", INI::parseReal, NULL, offsetof( SpectreGunshipUpdateModuleData, m_attackAreaRadius ) },
{ "StrafingIncrement", INI::parseRetailPerFrameReal, NULL, offsetof( SpectreGunshipUpdateModuleData, m_strafingIncrement ) },
{ "OrbitInsertionSlope", INI::parseReal, NULL, offsetof( SpectreGunshipUpdateModuleData, m_orbitInsertionSlope ) },
{ "RandomOffsetForHowitzer", INI::parseReal, NULL, offsetof( SpectreGunshipUpdateModuleData, m_randomOffsetForHowitzer ) },
{ "TargetingReticleRadius", INI::parseReal, NULL, offsetof( SpectreGunshipUpdateModuleData, m_targetingReticleRadius ) },
{ "GunshipOrbitRadius", INI::parseReal, NULL, offsetof( SpectreGunshipUpdateModuleData, m_gunshipOrbitRadius ) },
{ "HowitzerWeaponTemplate", INI::parseWeaponTemplate, NULL, offsetof( SpectreGunshipUpdateModuleData, m_howitzerWeaponTemplate ) },
{ "GattlingStrafeFXParticleSystem", INI::parseParticleSystemTemplate, NULL, offsetof( SpectreGunshipUpdateModuleData, m_gattlingStrafeFXParticleSystem ) },
{ "AttackAreaDecal", RadiusDecalTemplate::parseRadiusDecalTemplate, NULL, offsetof( SpectreGunshipUpdateModuleData, m_attackAreaDecalTemplate ) },
{ "TargetingReticleDecal", RadiusDecalTemplate::parseRadiusDecalTemplate, NULL, offsetof( SpectreGunshipUpdateModuleData, m_targetingReticleDecalTemplate ) },
{ 0, 0, 0, 0 }
};
p.add(dataFieldParse);
}
//-------------------------------------------------------------------------------------------------
SpectreGunshipUpdate::SpectreGunshipUpdate( Thing *thing, const ModuleData* moduleData ) : SpecialPowerUpdateModule( thing, moduleData )
{
m_specialPowerModule = NULL;
m_gattlingID = INVALID_ID;
m_status = GUNSHIP_STATUS_IDLE;
m_initialTargetPosition.zero();
m_overrideTargetDestination.zero();
m_gattlingTargetPosition.zero();
m_positionToShootAt.zero();
m_attackAreaDecal.clear();
m_targetingReticleDecal.clear();
m_orbitEscapeFrame = 0;
m_afterburnerSound = *(getObject()->getTemplate()->getPerUnitSound("Afterburner"));
m_howitzerFireSound = *(getObject()->getTemplate()->getPerUnitSound("HowitzerFire"));
m_okToFireHowitzerCounter = 0;
#if defined TRACKERS
m_howitzerTrackerDecal.clear();
#endif
}
//-------------------------------------------------------------------------------------------------
SpectreGunshipUpdate::~SpectreGunshipUpdate( void )
{
m_attackAreaDecal.clear();
m_targetingReticleDecal.clear();
#if defined TRACKERS
m_howitzerTrackerDecal.clear();
#endif
}
//-------------------------------------------------------------------------------------------------
// Validate that we have the necessary data from the ini file.
//-------------------------------------------------------------------------------------------------
void SpectreGunshipUpdate::onObjectCreated()
{
const SpectreGunshipUpdateModuleData *data = getSpectreGunshipUpdateModuleData();
Object *obj = getObject();
if( !data->m_specialPowerTemplate )
{
DEBUG_CRASH( ("%s object's SpectreGunshipUpdate lacks access to the SpecialPowerTemplate. Needs to be specified in ini.", obj->getTemplate()->getName().str() ) );
return;
}
m_specialPowerModule = obj->getSpecialPowerModule( data->m_specialPowerTemplate );
m_satellitePosition.set( obj->getPosition() );
}
//-------------------------------------------------------------------------------------------------
Bool SpectreGunshipUpdate::initiateIntentToDoSpecialPower(const SpecialPowerTemplate *specialPowerTemplate, const Object *targetObj, const Coord3D *targetPos, const Waypoint *way, UnsignedInt commandOptions )
{
const SpectreGunshipUpdateModuleData *data = getSpectreGunshipUpdateModuleData();
if( m_specialPowerModule->getSpecialPowerTemplate() != specialPowerTemplate )
{
//Check to make sure our modules are connected.
return FALSE;
}
if( !BitTest( commandOptions, COMMAND_FIRED_BY_SCRIPT ) )
{
m_initialTargetPosition.set( targetPos );
m_overrideTargetDestination.set( targetPos );
m_gattlingTargetPosition.set( targetPos );
}
else
{
UnsignedInt now = TheGameLogic->getFrame();
m_specialPowerModule->setReadyFrame( now );
m_initialTargetPosition.set( targetPos );
// a fresh gunship, so these were (0,0,0): the AI's and scripts' gunships aimed at the map corner
m_overrideTargetDestination.set( targetPos );
m_gattlingTargetPosition.set( targetPos );
setLogicalStatus( GUNSHIP_STATUS_INSERTING );
}
Object * gunShip = getObject();
if ( gunShip )
{
// MAKE TWEAKS TO AI SO SHIP MOVES PRETTY
AIUpdateInterface *shipAI = gunShip->getAIUpdateInterface();
if ( shipAI)
{
shipAI->chooseLocomotorSet( LOCOMOTORSET_PANIC );
shipAI->getCurLocomotor()->setAllowInvalidPosition(TRUE);
shipAI->getCurLocomotor()->setUltraAccurate(TRUE); // set ultra-accurate just so AI won't try to adjust our dest
}
Drawable *draw = gunShip->getDrawable();
if ( draw )
draw->clearAndSetModelConditionState( MODELCONDITION_DOOR_1_OPENING, MODELCONDITION_DOOR_1_CLOSING );
friend_enableAfterburners(TRUE);
setLogicalStatus( GUNSHIP_STATUS_INSERTING ); // The gunship is en route to the tharget area, from map-edge
// TELL THE GUNNERS ABOARD THE GUNSHIP TO HOLD THEIR FIRE UNTIL ORBIT INSERTION
ContainModuleInterface *shipContain = gunShip->getContain();
if ( shipContain )
{
Object *newGattling = TheGameLogic->findObjectByID( m_gattlingID );
const ThingTemplate *gattlingTemplate = TheThingFactory->findTemplate( data->m_gattlingTemplateName );
if( newGattling != NULL )
{
m_gattlingID = INVALID_ID;
newGattling = NULL;
}
if ( gattlingTemplate )
{
newGattling = TheThingFactory->newObject( gattlingTemplate, getObject()->getTeam() );
DEBUG_ASSERTCRASH( gunShip, ("SpecterGunshipUpdate failed to find or create a GATTLING object"));
shipContain->addToContain( newGattling );
m_gattlingID = newGattling->getID();
}
Object *gattling = TheGameLogic->findObjectByID( m_gattlingID );
if ( gattling )
gattling->setDisabled ( DISABLED_PARALYZED );
}
}
data->m_attackAreaDecalTemplate.createRadiusDecal( *getObject()->getPosition(), data->m_attackAreaRadius, getObject()->getControllingPlayer(), m_attackAreaDecal);
data->m_targetingReticleDecalTemplate.createRadiusDecal( *getObject()->getPosition(), data->m_targetingReticleRadius, getObject()->getControllingPlayer(), m_targetingReticleDecal);
#if defined TRACKERS
data->m_targetingReticleDecalTemplate.createRadiusDecal( *getObject()->getPosition(), data->m_targetingReticleRadius, getObject()->getControllingPlayer(), m_howitzerTrackerDecal);
#endif
SpecialPowerModuleInterface *spmInterface = getObject()->getSpecialPowerModule( specialPowerTemplate );
if( spmInterface )
{
SpecialPowerModule *spModule = (SpecialPowerModule*)spmInterface;
spModule->markSpecialPowerTriggered( &m_initialTargetPosition );
}
return TRUE;
}
//-------------------------------------------------------------------------------------------------
Bool SpectreGunshipUpdate::isPowerCurrentlyInUse( const CommandButton *command ) const
{
return false;
}
//-------------------------------------------------------------------------------------------------
void SpectreGunshipUpdate::setSpecialPowerOverridableDestination( const Coord3D *loc )
{
Object *me = getObject();
if( !me->isDisabled() )
{
// The orbit stays on the area the gunship was called to; update() clamps this aim inside it.
m_overrideTargetDestination = *loc;
DEBUG_LOG(("SPECTRE: frame %d gunship %d re-aimed at (%.0f,%.0f), area (%.0f,%.0f)\n",
TheGameLogic->getFrame(), (Int)me->getID(), loc->x, loc->y, m_initialTargetPosition.x, m_initialTargetPosition.y));
if( me->getControllingPlayer() && me->getControllingPlayer()->isLocalPlayer() )
{
AudioEventRTS soundToPlay = *me->getTemplate()->getVoiceAttack();
soundToPlay.setObjectID( me->getID() );
TheAudio->addAudioEvent(&soundToPlay);
}
}
}
//-------------------------------------------------------------------------------------------------
Bool SpectreGunshipUpdate::isPointOffMap( const Coord3D& testPos ) const
{
Region3D mapRegion;
TheTerrainLogic->getExtentIncludingBorder( &mapRegion );
if (!mapRegion.isInRegionNoZ( &testPos ))
return true;
return false;
}
// PARTITION FILTERS!
//-----------------------------------------------------------------------------
class PartitionFilterLiveMapEnemies : public PartitionFilter
{
private:
const Object *m_obj;
public:
PartitionFilterLiveMapEnemies(const Object *obj) : m_obj(obj) { }
virtual Bool allow(Object *objOther)
{
// this is way fast (bit test) so do it first.
if (objOther->isEffectivelyDead())
return false;
// this is also way fast (bit test) so do it next. The targets are on the map whatever the
// ship is: it orbits past the edge, and comparing its own off-map bit with the target's
// left the gattling with nothing to shoot for as long as the orbit was outside.
if (objOther->isOffMap())
return false;
Relationship r = m_obj->getRelationship(objOther);
if (r != ENEMIES)
return false;
return true;
}
#if defined(_DEBUG) || defined(_INTERNAL)
virtual const char* debugGetName() { return "PartitionFilterLiveMapEnemies"; }
#endif
};
//-----------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
/** The update callback. */
//-------------------------------------------------------------------------------------------------
UpdateSleepTime SpectreGunshipUpdate::update()
{
const SpectreGunshipUpdateModuleData *data = getSpectreGunshipUpdateModuleData();
Object *gunship = getObject();
if ( gunship )
{
if ( gunship->isEffectivelyDead() )
return UPDATE_SLEEP_FOREVER;
m_attackAreaDecal.update();
m_targetingReticleDecal.update();
#if defined TRACKERS
m_howitzerTrackerDecal.update();
#endif
AIUpdateInterface *shipAI = gunship->getAIUpdateInterface();
AIUpdateInterface *gattlingAI = NULL;
Object *gattling = TheGameLogic->findObjectByID( m_gattlingID );
if ( gattling )
{
gattlingAI = gattling->getAIUpdateInterface();
}
if ( m_status == GUNSHIP_STATUS_INSERTING || m_status == GUNSHIP_STATUS_ORBITING )
{
// init'l apogee
// target *<-------->*
// posi ^\ /
// | \ /
// perigee | \ /
// | */ declination
// | / \
// v/ * m_satelliteposition
// *
// |
// |
// |
// |
// |
// * gunship->getPosition()
//perigee is the point in the orbital arc nearest the satellite being captured
Coord3D perigee = *gunship->getPosition();
perigee.sub( &m_initialTargetPosition );
perigee.z = zero;
Real distanceToTarget = perigee.length();
perigee.normalize();
//apogee is the anteclockwise point fathest from the perigee line
Coord3D apogee;
apogee.z = zero;
apogee.x = -perigee.y;
apogee.y = perigee.x;
// declination intersects line [p][a], given an attack slope of n1/n2
Coord3D declination;
Real n1 = min( ORBIT_INSERTION_SLOPE_MAX, max(ORBIT_INSERTION_SLOPE_MIN, data->m_orbitInsertionSlope) );
Real n2 = ONE - n1;
declination.z = zero;
declination.x = ( perigee.x * n1 ) + ( apogee.x * n2 );
declination.y = ( perigee.y * n1 ) + ( apogee.y * n2 );
//scale out to the orbital radius
Real orbitalRadius = data->m_gunshipOrbitRadius;
declination.x *= orbitalRadius;
declination.y *= orbitalRadius;
m_satellitePosition.x = m_initialTargetPosition.x + declination.x;
m_satellitePosition.y = m_initialTargetPosition.y + declination.y;
if ( shipAI)
{
shipAI->aiMoveToPosition( &m_satellitePosition, CMD_FROM_AI );
}
Real constraintRadius = data->m_attackAreaRadius - data->m_targetingReticleRadius;
//Constrain Target Override to the targeting radius
Coord3D overrideTargetDelta = m_initialTargetPosition;
overrideTargetDelta.sub( &m_overrideTargetDestination );
if ( overrideTargetDelta.length() > constraintRadius )
{
overrideTargetDelta.normalize();
overrideTargetDelta.x *= constraintRadius;
overrideTargetDelta.y *= constraintRadius;
m_overrideTargetDestination.x = m_initialTargetPosition.x - overrideTargetDelta.x;
m_overrideTargetDestination.y = m_initialTargetPosition.y - overrideTargetDelta.y;
}
m_attackAreaDecal.setPosition( m_initialTargetPosition );
m_targetingReticleDecal.setPosition( m_overrideTargetDestination );
#if defined TRACKERS
m_howitzerTrackerDecal.setPosition( m_gattlingTargetPosition );
#endif
if ( (m_status == GUNSHIP_STATUS_INSERTING) && (distanceToTarget < orbitalRadius ) )// close enough to shoot
{
setLogicalStatus( GUNSHIP_STATUS_ORBITING );
m_orbitEscapeFrame = TheGameLogic->getFrame() + data->m_orbitFrames;
Object *gattling = TheGameLogic->findObjectByID( m_gattlingID );
if ( gattling )
gattling->clearDisabled ( DISABLED_PARALYZED );
AIUpdateInterface *shipAI = gunship->getAIUpdateInterface();
if ( shipAI)
{
shipAI->chooseLocomotorSet( LOCOMOTORSET_NORMAL );
shipAI->getCurLocomotor()->setAllowInvalidPosition(TRUE);
shipAI->getCurLocomotor()->setUltraAccurate(TRUE); // set ultra-accurate just so AI won't try to adjust our dest
}
Drawable *draw = gunship->getDrawable();
if ( draw )
draw->clearAndSetModelConditionState( MODELCONDITION_DOOR_1_CLOSING, MODELCONDITION_DOOR_1_OPENING );
friend_enableAfterburners(FALSE);
}
} // endif status == ORBITING || INSERTING
if ( m_status == GUNSHIP_STATUS_ORBITING )
{
Object *validTargetObject = NULL;
if ( TheGameLogic->getFrame() >= m_orbitEscapeFrame )
{
cleanUp();
setLogicalStatus( GUNSHIP_STATUS_DEPARTING );
// CEASE FIRE, RETURN TO BASE
disengageAndDepartAO( gunship );
}//endif escapeframe
else
{
// ONLY EVERY FEW FRAMES DO WE RE_EVALUATE THE TARGET OBJECT
if ( TheGameLogic->getFrame() %data->m_howitzerFiringRate < ONE )
{
m_positionToShootAt = m_overrideTargetDestination; // unless we get a hit, below
PartitionFilterLiveMapEnemies filterObvious( gunship );
PartitionFilterStealthedAndUndetected filterStealth( gunship, false );
PartitionFilterPossibleToAttack filterAttack(ATTACK_NEW_TARGET, gunship, CMD_FROM_AI);
PartitionFilterFreeOfFog filterFogged( gunship->getControllingPlayer()->getPlayerIndex() );
PartitionFilter *filters[6];
Int numFilters = 0;
filters[numFilters++] = &filterObvious;
filters[numFilters++] = &filterStealth;
filters[numFilters++] = &filterAttack;
filters[numFilters++] = &filterFogged;
filters[numFilters] = NULL;
// THIS WILL FIND A VALID TARGET WITHIN THE TARGETING RETICLE
ObjectIterator *iter = ThePartitionManager->iterateObjectsInRange(&m_overrideTargetDestination,
data->m_targetingReticleRadius,
FROM_BOUNDINGSPHERE_2D,
filters,
ITER_SORTED_NEAR_TO_FAR);
MemoryPoolObjectHolder holder(iter);
for (Object *theEnemy = iter->first(); theEnemy; theEnemy = iter->next())
{
if ( theEnemy && isFairDistanceFromShip( theEnemy ) )
{
validTargetObject = theEnemy;
break;
}
}
// EA kept this wide acquire from human players so the gunship needed babysitting, which
// left it hosing the empty reticle while enemies stood beside it. Everyone gets it now.
{
if ( ! validTargetObject )
{
// set a flag to start the targeting decal fading, since there is nothing to kill there
// THIS WILL FIND A VALID TARGET ANYWHERE INSIDE THE TARGETING AREA (THE BIG CIRCLE)
ObjectIterator *iter = ThePartitionManager->iterateObjectsInRange(&m_initialTargetPosition,
data->m_attackAreaRadius,
FROM_BOUNDINGSPHERE_2D,
filters,
ITER_SORTED_NEAR_TO_FAR);
MemoryPoolObjectHolder holder(iter);
for (Object *theEnemy = iter->first(); theEnemy; theEnemy = iter->next())
{
if ( theEnemy && isFairDistanceFromShip( theEnemy ) )
{
// WE GOT A HIT!!!! SHOOT HIM!
validTargetObject = theEnemy;
m_positionToShootAt = *validTargetObject->getPosition();
break;
}
}
}
}
//lets keep a constant barrage of gattling bullets on the current aim location
if( gattlingAI )
{
if ( validTargetObject )// either in the reticle or the targeting area
gattlingAI->aiAttackObject( validTargetObject, LOTS_OF_SHOTS, CMD_FROM_AI );
else
gattlingAI->aiAttackPosition( &m_gattlingTargetPosition, LOTS_OF_SHOTS, CMD_FROM_AI );
}
// IF THE GATTLING GUN HAS BEEN PLINKING THE TARGET LONG ENOUGH, LETS FOLLOW WITH A VOLLEY OF HOWITZER FIRE
if ( m_okToFireHowitzerCounter > data->m_howitzerFollowLag )
{
WeaponTemplate *wt = data->m_howitzerWeaponTemplate;
if( wt )
{
Coord3D attackPositionWithRandomOffset;
Real offs = data->m_randomOffsetForHowitzer;
attackPositionWithRandomOffset.x = m_gattlingTargetPosition.x + GameLogicRandomValue( -offs, offs );
attackPositionWithRandomOffset.y = m_gattlingTargetPosition.y + GameLogicRandomValue( -offs, offs );
attackPositionWithRandomOffset.z = m_gattlingTargetPosition.z;
TheWeaponStore->createAndFireTempWeapon( wt, gunship, &attackPositionWithRandomOffset ); m_howitzerFireSound.setObjectID(gunship->getID());
TheAudio->addAudioEvent( &m_howitzerFireSound );
}
}
}//endif frame modulator
// GATTLING TARGETING LOGIC------------------------------------------
// TheSuperHackers @fix A missing client-side particle template used to switch off the
// gattling's aiming and its howitzer counter, which are logic state and CRC'd.
// The aim walks toward the next good spot whether or not the gun is firing: EA's walked only
// while it fired, so a re-aim beyond the gun's reach left it stuck on the old spot for good.
// The howitzer still waits for the gattling to have plinked the spot.
Bool gattlingFiring = gattling && gattling->testStatus( OBJECT_STATUS_IS_FIRING_WEAPON );
if (gattling)
{
Coord3D delta = m_positionToShootAt;
delta.sub( &m_gattlingTargetPosition );
Real dist = delta.length();
if ( dist < data->m_strafingIncrement )
{
m_gattlingTargetPosition = m_positionToShootAt;
if ( gattlingFiring )
++m_okToFireHowitzerCounter;
}
else
{
m_okToFireHowitzerCounter = ZERO;
delta.normalize();
delta.scale( data->m_strafingIncrement );
m_gattlingTargetPosition.add( &delta );
}
}
if (gattlingFiring)
{
const Player *localPlayer = ThePlayerList->getLocalPlayer();
//Make sure the gunship is visible to the player before drawing effects.
if ( gunship->getShroudedStatus( localPlayer->getPlayerIndex() ) <= OBJECTSHROUD_PARTIAL_CLEAR )
{
// This makes the client smoke effects of the gattling cannon strafing the ground toward the attack position
ParticleSystem *sys = TheParticleSystemManager->createParticleSystem(data->m_gattlingStrafeFXParticleSystem);
if (sys)
{
Coord3D impactPosition;
impactPosition.x = m_gattlingTargetPosition.x + GameClientRandomValueReal( -5.0f, 5.0f );
impactPosition.y = m_gattlingTargetPosition.y + GameClientRandomValueReal( -5.0f, 5.0f );
impactPosition.z = TheTerrainLogic->getGroundHeight( impactPosition.x, impactPosition.y );
sys->setPosition( &impactPosition );
}
}
}
}// end else
}//not orbiting
else if ( m_status == GUNSHIP_STATUS_DEPARTING )
{
if ( isPointOffMap( *gunship->getPosition() ) )
{
TheGameLogic->destroyObject( gunship );
setLogicalStatus( GUNSHIP_STATUS_IDLE );
cleanUp();
// HERE WE NEED TO CLEAN UP THE TERRAIN DECALS, AND ANYTHING ELSE THAT WAS CREATED IN INIT-INTENT[]
}
}
} // endif gunship
else if ( m_status != GUNSHIP_STATUS_IDLE )
{
//OH MY GOODNESS, THE GUNSHIP MUST HAVE GOTTEN SHOT DOWN!
setLogicalStatus( GUNSHIP_STATUS_IDLE );
cleanUp();
}
return UPDATE_SLEEP_NONE;
}
//-------------------------------------------------------------------------------------------------
void SpectreGunshipUpdate::friend_enableAfterburners(Bool v)
{
Object* gunship = getObject();
if (v)
{
gunship->setModelConditionState(MODELCONDITION_JETAFTERBURNER);
if (!m_afterburnerSound.isCurrentlyPlaying())
{
m_afterburnerSound.setObjectID(gunship->getID());
m_afterburnerSound.setPlayingHandle(TheAudio->addAudioEvent(&m_afterburnerSound));
}
}
else
{
gunship->clearModelConditionState(MODELCONDITION_JETAFTERBURNER);
if (m_afterburnerSound.isCurrentlyPlaying())
{
TheAudio->removeAudioEvent(m_afterburnerSound.getPlayingHandle());
}
}
}
Bool SpectreGunshipUpdate::isFairDistanceFromShip( Object *target )
{
Object *gunship = getObject();
if ( !gunship )
return FALSE;
if ( ! target )
return FALSE;
const Coord3D *targetPosition = target->getPosition();
const Coord3D *gunshipPosition = gunship->getPosition();
Coord3D shipToTargetDelta;
shipToTargetDelta.x = gunshipPosition->x - targetPosition->x;
shipToTargetDelta.y = gunshipPosition->y - targetPosition->y;
shipToTargetDelta.z = 0.0f;
return (shipToTargetDelta.length() > getSpectreGunshipUpdateModuleData()->m_gunshipOrbitRadius * 0.75f );
}
//-------------------------------------------------------------------------------------------------
void SpectreGunshipUpdate::cleanUp()
{
m_attackAreaDecal.clear();
m_targetingReticleDecal.clear();
Object *gattling = TheGameLogic->findObjectByID( m_gattlingID );
if ( gattling )
TheGameLogic->destroyObject( gattling );
#if defined TRACKERS
m_howitzerTrackerDecal.clear();
#endif
}
// --------------------------------------------------------------------------------------------------
void SpectreGunshipUpdate::disengageAndDepartAO( Object *gunship )
{
if ( gunship == NULL )
return;
AIUpdateInterface *shipAI = gunship->getAIUpdateInterface();
if ( shipAI)
{
Coord3D exitPoint;// head off the map in the direction you are facing
gunship->getUnitDirectionVector3D( exitPoint );
Real mapSize = 99999.0f;
exitPoint.x *= mapSize;
exitPoint.y *= mapSize;
exitPoint.add( gunship->getPosition() );
shipAI->aiMoveToPosition( &exitPoint, CMD_FROM_AI );
}
Object *gattling = TheGameLogic->findObjectByID( m_gattlingID );
if ( gattling )
gattling->setDisabled ( DISABLED_PARALYZED );
if ( shipAI)
{
shipAI->chooseLocomotorSet( LOCOMOTORSET_PANIC );
shipAI->getCurLocomotor()->setAllowInvalidPosition(TRUE);
shipAI->getCurLocomotor()->setUltraAccurate(TRUE); // set ultra-accurate just so AI won't try to adjust our dest
}
Drawable *draw = gunship->getDrawable();
if ( draw )
draw->clearAndSetModelConditionState( MODELCONDITION_DOOR_1_OPENING, MODELCONDITION_DOOR_1_CLOSING );
friend_enableAfterburners(TRUE);
cleanUp();
return;
}
//-------------------------------------------------------------------------------------------------
Bool SpectreGunshipUpdate::doesSpecialPowerHaveOverridableDestinationActive() const
{
return m_status < GUNSHIP_STATUS_DEPARTING;
}
// ------------------------------------------------------------------------------------------------
/** CRC */
// ------------------------------------------------------------------------------------------------
void SpectreGunshipUpdate::crc( Xfer *xfer )
{
// extend base class
UpdateModule::crc( xfer );
} // end crc
// ------------------------------------------------------------------------------------------------
/** Xfer method
* Version Info:
* 1: Initial version
* 2: Can't flat-save decals, that's a hella crash (they aren't saved (no memory) and they have a pointer in them). And half the class wasn't saved.
*/
// ------------------------------------------------------------------------------------------------
void SpectreGunshipUpdate::xfer( Xfer *xfer )
{
// const SpectreGunshipUpdateModuleData *data = getSpectreGunshipUpdateModuleData();
// version
XferVersion currentVersion = 2;
XferVersion version = currentVersion;
xfer->xferVersion( &version, currentVersion );
// extend base class
UpdateModule::xfer( xfer );
// The initial target destination.
xfer->xferCoord3D( &m_initialTargetPosition );
// The manual override target destination.
xfer->xferCoord3D( &m_overrideTargetDestination );
// The current move-to point of the gunship.
xfer->xferCoord3D( &m_satellitePosition );
// status
xfer->xferUser( &m_status, sizeof( GunshipStatus ) );
xfer->xferUnsignedInt( &m_orbitEscapeFrame );
if( version < 2 )
{
xfer->xferUser( &m_attackAreaDecal, sizeof( RadiusDecal ) );
xfer->xferUser( &m_targetingReticleDecal, sizeof( RadiusDecal ) );
#if defined TRACKERS
xfer->xferUser( &m_howitzerTrackerDecal, sizeof( RadiusDecal ) );
#endif
}
if( version >= 2 )
{
xfer->xferCoord3D( &m_gattlingTargetPosition );
xfer->xferCoord3D( &m_positionToShootAt );
xfer->xferUnsignedInt( &m_okToFireHowitzerCounter );
xfer->xferObjectID( &m_gattlingID );
}
} // end xfer
// ------------------------------------------------------------------------------------------------
/** Load post process */
// ------------------------------------------------------------------------------------------------
void SpectreGunshipUpdate::loadPostProcess( void )
{
// extend base class
UpdateModule::loadPostProcess();
} // end loadPostProcess