You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4431 lines
126 KiB
4431 lines
126 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
//============================================================================= |
|
|
|
#include "cbase.h" |
|
#include "func_tank.h" |
|
#include "Sprite.h" |
|
#include "EnvLaser.h" |
|
#include "basecombatweapon.h" |
|
#include "explode.h" |
|
#include "eventqueue.h" |
|
#include "gamerules.h" |
|
#include "ammodef.h" |
|
#include "in_buttons.h" |
|
#include "soundent.h" |
|
#include "ndebugoverlay.h" |
|
#include "grenade_beam.h" |
|
#include "vstdlib/random.h" |
|
#include "engine/IEngineSound.h" |
|
#include "physics_cannister.h" |
|
#include "decals.h" |
|
#include "shake.h" |
|
#include "particle_smokegrenade.h" |
|
#include "player.h" |
|
#include "entitylist.h" |
|
#include "IEffects.h" |
|
#include "ai_basenpc.h" |
|
#include "ai_behavior_functank.h" |
|
#include "weapon_rpg.h" |
|
#include "effects.h" |
|
#include "iservervehicle.h" |
|
#include "soundenvelope.h" |
|
#include "effect_dispatch_data.h" |
|
#include "te_effect_dispatch.h" |
|
#include "props.h" |
|
#include "rumble_shared.h" |
|
#include "particle_parse.h" |
|
// NVNT turret recoil |
|
#include "haptics/haptic_utils.h" |
|
|
|
#ifdef HL2_DLL |
|
#include "hl2_player.h" |
|
#endif //HL2_DLL |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
extern Vector PointOnLineNearestPoint(const Vector& vStartPos, const Vector& vEndPos, const Vector& vPoint); |
|
|
|
ConVar mortar_visualize("mortar_visualize", "0" ); |
|
|
|
BEGIN_DATADESC( CFuncTank ) |
|
DEFINE_KEYFIELD( m_yawRate, FIELD_FLOAT, "yawrate" ), |
|
DEFINE_KEYFIELD( m_yawRange, FIELD_FLOAT, "yawrange" ), |
|
DEFINE_KEYFIELD( m_yawTolerance, FIELD_FLOAT, "yawtolerance" ), |
|
DEFINE_KEYFIELD( m_pitchRate, FIELD_FLOAT, "pitchrate" ), |
|
DEFINE_KEYFIELD( m_pitchRange, FIELD_FLOAT, "pitchrange" ), |
|
DEFINE_KEYFIELD( m_pitchTolerance, FIELD_FLOAT, "pitchtolerance" ), |
|
DEFINE_KEYFIELD( m_fireRate, FIELD_FLOAT, "firerate" ), |
|
DEFINE_FIELD( m_fireTime, FIELD_TIME ), |
|
DEFINE_KEYFIELD( m_persist, FIELD_FLOAT, "persistence" ), |
|
DEFINE_KEYFIELD( m_persist2, FIELD_FLOAT, "persistence2" ), |
|
DEFINE_KEYFIELD( m_minRange, FIELD_FLOAT, "minRange" ), |
|
DEFINE_KEYFIELD( m_maxRange, FIELD_FLOAT, "maxRange" ), |
|
DEFINE_FIELD( m_flMinRange2, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_flMaxRange2, FIELD_FLOAT ), |
|
DEFINE_KEYFIELD( m_iAmmoCount, FIELD_INTEGER, "ammo_count" ), |
|
DEFINE_KEYFIELD( m_spriteScale, FIELD_FLOAT, "spritescale" ), |
|
DEFINE_KEYFIELD( m_iszSpriteSmoke, FIELD_STRING, "spritesmoke" ), |
|
DEFINE_KEYFIELD( m_iszSpriteFlash, FIELD_STRING, "spriteflash" ), |
|
DEFINE_KEYFIELD( m_bulletType, FIELD_INTEGER, "bullet" ), |
|
DEFINE_FIELD( m_nBulletCount, FIELD_INTEGER ), |
|
DEFINE_KEYFIELD( m_spread, FIELD_INTEGER, "firespread" ), |
|
DEFINE_KEYFIELD( m_iBulletDamage, FIELD_INTEGER, "bullet_damage" ), |
|
DEFINE_KEYFIELD( m_iBulletDamageVsPlayer, FIELD_INTEGER, "bullet_damage_vs_player" ), |
|
DEFINE_KEYFIELD( m_iszMaster, FIELD_STRING, "master" ), |
|
|
|
#ifdef HL2_EPISODIC |
|
DEFINE_KEYFIELD( m_iszAmmoType, FIELD_STRING, "ammotype" ), |
|
DEFINE_FIELD( m_iAmmoType, FIELD_INTEGER ), |
|
#else |
|
DEFINE_FIELD( m_iSmallAmmoType, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_iMediumAmmoType, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_iLargeAmmoType, FIELD_INTEGER ), |
|
#endif // HL2_EPISODIC |
|
|
|
DEFINE_KEYFIELD( m_soundStartRotate, FIELD_SOUNDNAME, "rotatestartsound" ), |
|
DEFINE_KEYFIELD( m_soundStopRotate, FIELD_SOUNDNAME, "rotatestopsound" ), |
|
DEFINE_KEYFIELD( m_soundLoopRotate, FIELD_SOUNDNAME, "rotatesound" ), |
|
DEFINE_KEYFIELD( m_flPlayerGracePeriod, FIELD_FLOAT, "playergraceperiod" ), |
|
DEFINE_KEYFIELD( m_flIgnoreGraceUpto, FIELD_FLOAT, "ignoregraceupto" ), |
|
DEFINE_KEYFIELD( m_flPlayerLockTimeBeforeFire, FIELD_FLOAT, "playerlocktimebeforefire" ), |
|
DEFINE_FIELD( m_flLastSawNonPlayer, FIELD_TIME ), |
|
|
|
DEFINE_FIELD( m_yawCenter, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_yawCenterWorld, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_pitchCenter, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_pitchCenterWorld, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_fireLast, FIELD_TIME ), |
|
DEFINE_FIELD( m_lastSightTime, FIELD_TIME ), |
|
DEFINE_FIELD( m_barrelPos, FIELD_VECTOR ), |
|
DEFINE_FIELD( m_sightOrigin, FIELD_POSITION_VECTOR ), |
|
DEFINE_FIELD( m_hFuncTankTarget, FIELD_EHANDLE ), |
|
DEFINE_FIELD( m_hController, FIELD_EHANDLE ), |
|
DEFINE_FIELD( m_vecControllerUsePos, FIELD_VECTOR ), |
|
DEFINE_FIELD( m_flNextAttack, FIELD_TIME ), |
|
DEFINE_FIELD( m_targetEntityName, FIELD_STRING ), |
|
DEFINE_FIELD( m_hTarget, FIELD_EHANDLE ), |
|
DEFINE_FIELD( m_vTargetPosition, FIELD_POSITION_VECTOR ), |
|
DEFINE_FIELD( m_vecNPCIdleTarget, FIELD_POSITION_VECTOR ), |
|
DEFINE_FIELD( m_persist2burst, FIELD_FLOAT), |
|
//DEFINE_FIELD( m_parentMatrix, FIELD_MATRIX ), // DON'T SAVE |
|
DEFINE_FIELD( m_hControlVolume, FIELD_EHANDLE ), |
|
DEFINE_KEYFIELD( m_iszControlVolume, FIELD_STRING, "control_volume" ), |
|
DEFINE_FIELD( m_flNextControllerSearch, FIELD_TIME ), |
|
DEFINE_FIELD( m_bShouldFindNPCs, FIELD_BOOLEAN ), |
|
DEFINE_FIELD( m_bNPCInRoute, FIELD_BOOLEAN ), |
|
DEFINE_KEYFIELD( m_iszNPCManPoint, FIELD_STRING, "npc_man_point" ), |
|
DEFINE_FIELD( m_bReadyToFire, FIELD_BOOLEAN ), |
|
|
|
DEFINE_KEYFIELD( m_bPerformLeading, FIELD_BOOLEAN, "LeadTarget" ), |
|
DEFINE_FIELD( m_flStartLeadFactor, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_flStartLeadFactorTime, FIELD_TIME ), |
|
DEFINE_FIELD( m_flNextLeadFactor, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_flNextLeadFactorTime, FIELD_TIME ), |
|
|
|
// Used for when the gun is attached to another entity |
|
DEFINE_KEYFIELD( m_iszBaseAttachment, FIELD_STRING, "gun_base_attach" ), |
|
DEFINE_KEYFIELD( m_iszBarrelAttachment, FIELD_STRING, "gun_barrel_attach" ), |
|
// DEFINE_FIELD( m_nBarrelAttachment, FIELD_INTEGER ), |
|
|
|
// Used when the gun is actually a part of the parent entity, and pose params aim it |
|
DEFINE_KEYFIELD( m_iszYawPoseParam, FIELD_STRING, "gun_yaw_pose_param" ), |
|
DEFINE_KEYFIELD( m_iszPitchPoseParam, FIELD_STRING, "gun_pitch_pose_param" ), |
|
DEFINE_KEYFIELD( m_flYawPoseCenter, FIELD_FLOAT, "gun_yaw_pose_center" ), |
|
DEFINE_KEYFIELD( m_flPitchPoseCenter, FIELD_FLOAT, "gun_pitch_pose_center" ), |
|
DEFINE_FIELD( m_bUsePoseParameters, FIELD_BOOLEAN ), |
|
|
|
DEFINE_KEYFIELD( m_iEffectHandling, FIELD_INTEGER, "effecthandling" ), |
|
|
|
// Inputs |
|
DEFINE_INPUTFUNC( FIELD_VOID, "Activate", InputActivate ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "Deactivate", InputDeactivate ), |
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetFireRate", InputSetFireRate ), |
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetDamage", InputSetDamage ), |
|
DEFINE_INPUTFUNC( FIELD_VECTOR, "SetTargetPosition", InputSetTargetPosition ), |
|
DEFINE_INPUTFUNC( FIELD_VECTOR, "SetTargetDir", InputSetTargetDir ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "SetTargetEntityName", InputSetTargetEntityName ), |
|
DEFINE_INPUTFUNC( FIELD_EHANDLE, "SetTargetEntity", InputSetTargetEntity ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "ClearTargetEntity", InputClearTargetEntity ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "FindNPCToManTank", InputFindNPCToManTank ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "StopFindingNPCs", InputStopFindingNPCs ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "StartFindingNPCs", InputStartFindingNPCs ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "ForceNPCOff", InputForceNPCOff ), |
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetMaxRange", InputSetMaxRange ), |
|
|
|
// Outputs |
|
DEFINE_OUTPUT(m_OnFire, "OnFire"), |
|
DEFINE_OUTPUT(m_OnLoseTarget, "OnLoseTarget"), |
|
DEFINE_OUTPUT(m_OnAquireTarget, "OnAquireTarget"), |
|
DEFINE_OUTPUT(m_OnAmmoDepleted, "OnAmmoDepleted"), |
|
DEFINE_OUTPUT(m_OnGotController, "OnGotController"), |
|
DEFINE_OUTPUT(m_OnLostController, "OnLostController"), |
|
DEFINE_OUTPUT(m_OnGotPlayerController, "OnGotPlayerController"), |
|
DEFINE_OUTPUT(m_OnLostPlayerController, "OnLostPlayerController"), |
|
DEFINE_OUTPUT(m_OnReadyToFire, "OnReadyToFire"), |
|
END_DATADESC() |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
CFuncTank::CFuncTank() |
|
{ |
|
m_nBulletCount = 0; |
|
|
|
m_bNPCInRoute = false; |
|
m_flNextControllerSearch = 0; |
|
m_bShouldFindNPCs = true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
CFuncTank::~CFuncTank( void ) |
|
{ |
|
if ( m_soundLoopRotate != NULL_STRING && ( m_spawnflags & SF_TANK_SOUNDON ) ) |
|
{ |
|
StopSound( entindex(), CHAN_STATIC, STRING(m_soundLoopRotate) ); |
|
} |
|
} |
|
|
|
|
|
//------------------------------------------------------------------------------ |
|
// Purpose: |
|
//------------------------------------------------------------------------------ |
|
inline bool CFuncTank::CanFire( void ) |
|
{ |
|
float flTimeDelay = gpGlobals->curtime - m_lastSightTime; |
|
|
|
// Fire when can't see enemy if time is less that persistence time |
|
if ( flTimeDelay <= m_persist ) |
|
return true; |
|
|
|
// Fire when I'm in a persistence2 burst |
|
if ( flTimeDelay <= m_persist2burst ) |
|
return true; |
|
|
|
// If less than persistence2, occasionally do another burst |
|
if ( flTimeDelay <= m_persist2 ) |
|
{ |
|
if ( random->RandomInt( 0, 30 ) == 0 ) |
|
{ |
|
m_persist2burst = flTimeDelay + 0.5f; |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// Purpose: Input handler for activating the tank. |
|
//------------------------------------------------------------------------------ |
|
void CFuncTank::InputActivate( inputdata_t &inputdata ) |
|
{ |
|
TankActivate(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::TankActivate( void ) |
|
{ |
|
m_spawnflags |= SF_TANK_ACTIVE; |
|
SetNextThink( gpGlobals->curtime + 0.1f ); |
|
m_fireLast = gpGlobals->curtime; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Input handler for deactivating the tank. |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputDeactivate( inputdata_t &inputdata ) |
|
{ |
|
TankDeactivate(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::TankDeactivate( void ) |
|
{ |
|
m_spawnflags &= ~SF_TANK_ACTIVE; |
|
m_fireLast = 0; |
|
StopRotSound(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Input handler for changing the name of the tank's target entity. |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputSetTargetEntityName( inputdata_t &inputdata ) |
|
{ |
|
m_targetEntityName = inputdata.value.StringID(); |
|
m_hTarget = FindTarget( m_targetEntityName, inputdata.pActivator ); |
|
|
|
// No longer aim at target position if have one |
|
m_spawnflags &= ~SF_TANK_AIM_AT_POS; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Input handler for setting a new target entity by ehandle. |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputSetTargetEntity( inputdata_t &inputdata ) |
|
{ |
|
if ( inputdata.value.Entity() != NULL ) |
|
{ |
|
m_targetEntityName = inputdata.value.Entity()->GetEntityName(); |
|
} |
|
else |
|
{ |
|
m_targetEntityName = NULL_STRING; |
|
} |
|
m_hTarget = inputdata.value.Entity(); |
|
|
|
// No longer aim at target position if have one |
|
m_spawnflags &= ~SF_TANK_AIM_AT_POS; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Input handler for clearing the tank's target entity |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputClearTargetEntity( inputdata_t &inputdata ) |
|
{ |
|
m_targetEntityName = NULL_STRING; |
|
m_hTarget = NULL; |
|
|
|
// No longer aim at target position if have one |
|
m_spawnflags &= ~SF_TANK_AIM_AT_POS; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Input handler for setting the rate of fire in shots per second. |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputSetFireRate( inputdata_t &inputdata ) |
|
{ |
|
m_fireRate = inputdata.value.Float(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Input handler for setting the damage |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputSetDamage( inputdata_t &inputdata ) |
|
{ |
|
m_iBulletDamage = inputdata.value.Int(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Input handler for setting the target as a position. |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputSetTargetPosition( inputdata_t &inputdata ) |
|
{ |
|
m_spawnflags |= SF_TANK_AIM_AT_POS; |
|
m_hTarget = NULL; |
|
|
|
inputdata.value.Vector3D( m_vTargetPosition ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Input handler for setting the target as a position. |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputSetTargetDir( inputdata_t &inputdata ) |
|
{ |
|
m_spawnflags |= SF_TANK_AIM_AT_POS; |
|
m_hTarget = NULL; |
|
|
|
Vector vecTargetDir; |
|
inputdata.value.Vector3D( vecTargetDir ); |
|
m_vTargetPosition = GetAbsOrigin() + m_barrelPos.LengthSqr() * vecTargetDir; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Input handler for telling the func_tank to find an NPC to man it. |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputFindNPCToManTank( inputdata_t &inputdata ) |
|
{ |
|
// Verify the func_tank is controllable and available. |
|
if ( !IsNPCControllable() && !IsNPCSetController() ) |
|
return; |
|
|
|
// If we have a controller already - don't look for one. |
|
if ( HasController() ) |
|
return; |
|
|
|
// NPC assigned to man the func_tank? |
|
CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, inputdata.value.StringID() ); |
|
if ( pEntity ) |
|
{ |
|
CAI_BaseNPC *pNPC = pEntity->MyNPCPointer(); |
|
if ( pNPC ) |
|
{ |
|
// Verify the npc has the func_tank controller behavior. |
|
CAI_FuncTankBehavior *pBehavior; |
|
if ( pNPC->GetBehavior( &pBehavior ) ) |
|
{ |
|
m_hController = pNPC; |
|
pBehavior->SetFuncTank( this ); |
|
NPC_SetInRoute( true ); |
|
return; |
|
} |
|
} |
|
} |
|
|
|
// No controller? Find a nearby NPC who can man this func_tank. |
|
NPC_FindController(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : &inputdata - |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputStopFindingNPCs( inputdata_t &inputdata ) |
|
{ |
|
m_bShouldFindNPCs = false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : &inputdata - |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputStartFindingNPCs( inputdata_t &inputdata ) |
|
{ |
|
m_bShouldFindNPCs = true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : &inputdata - |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputForceNPCOff( inputdata_t &inputdata ) |
|
{ |
|
// Interrupt any npc in route (ally or not). |
|
if ( NPC_InRoute() ) |
|
{ |
|
// Interrupt the npc's route. |
|
NPC_InterruptRoute(); |
|
} |
|
|
|
// If we don't have a controller - then the gun should be free. |
|
if ( !m_hController ) |
|
return; |
|
|
|
CAI_BaseNPC *pNPC = m_hController->MyNPCPointer(); |
|
if ( !pNPC ) |
|
return; |
|
|
|
CAI_FuncTankBehavior *pBehavior; |
|
if ( pNPC->GetBehavior( &pBehavior ) ) |
|
{ |
|
pBehavior->Dismount(); |
|
} |
|
|
|
m_hController = NULL; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : &inputdata - |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::InputSetMaxRange( inputdata_t &inputdata ) |
|
{ |
|
m_maxRange = inputdata.value.Float(); |
|
m_flMaxRange2 = m_maxRange * m_maxRange; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Find the closest NPC with the func_tank behavior. |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::NPC_FindController( void ) |
|
{ |
|
// Not NPC controllable or controllable on by specified npc's return. |
|
if ( !IsNPCControllable() || IsNPCSetController() ) |
|
return; |
|
|
|
// Initialize for finding closest NPC. |
|
CAI_BaseNPC *pClosestNPC = NULL; |
|
float flClosestDist2 = ( FUNCTANK_DISTANCE_MAX * FUNCTANK_DISTANCE_MAX ); |
|
float flMinDistToEnemy2 = ( FUNCTANK_DISTANCE_MIN_TO_ENEMY * FUNCTANK_DISTANCE_MIN_TO_ENEMY ); |
|
CAI_FuncTankBehavior *pClosestBehavior = NULL; |
|
|
|
// Get the mount position. |
|
Vector vecMountPos; |
|
NPC_FindManPoint( vecMountPos ); |
|
|
|
// Search through the AI list for the closest NPC with the func_tank behavior. |
|
CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs(); |
|
int nAICount = g_AI_Manager.NumAIs(); |
|
for ( int iAI = 0; iAI < nAICount; ++iAI ) |
|
{ |
|
CAI_BaseNPC *pNPC = ppAIs[iAI]; |
|
if ( !pNPC ) |
|
continue; |
|
|
|
if ( !pNPC->IsAlive() ) |
|
continue; |
|
|
|
if ( pNPC->IsInAScript() ) |
|
continue; |
|
|
|
CAI_FuncTankBehavior *pBehavior; |
|
if ( pNPC->GetBehavior( &pBehavior ) ) |
|
{ |
|
// Don't mount the func_tank if your "enemy" is within X feet or it or the npc. |
|
CBaseEntity *pEnemy = pNPC->GetEnemy(); |
|
|
|
if ( pEnemy ) |
|
{ |
|
if ( !IsEntityInViewCone(pEnemy) ) |
|
{ |
|
// Don't mount the tank if the tank can't be aimed at the enemy. |
|
continue; |
|
} |
|
|
|
float flDist2 = ( pEnemy->GetAbsOrigin() - pNPC->GetAbsOrigin() ).LengthSqr(); |
|
if ( flDist2 < flMinDistToEnemy2 ) |
|
continue; |
|
|
|
flDist2 = ( vecMountPos - pEnemy->GetAbsOrigin() ).LengthSqr(); |
|
if ( flDist2 < flMinDistToEnemy2 ) |
|
continue; |
|
|
|
if ( !pNPC->FVisible( vecMountPos + pNPC->GetViewOffset() ) ) |
|
continue; |
|
} |
|
|
|
trace_t tr; |
|
UTIL_TraceEntity( pNPC, vecMountPos, vecMountPos, MASK_NPCSOLID, this, pNPC->GetCollisionGroup(), &tr ); |
|
if( tr.startsolid || tr.fraction < 1.0 ) |
|
{ |
|
// Don't mount the tank if someone/something is located on the control point. |
|
continue; |
|
} |
|
|
|
if ( !pBehavior->HasFuncTank() && !pBehavior->IsBusy() ) |
|
{ |
|
float flDist2 = ( vecMountPos - pNPC->GetAbsOrigin() ).LengthSqr(); |
|
if ( flDist2 < flClosestDist2 ) |
|
{ |
|
pClosestNPC = pNPC; |
|
pClosestBehavior = pBehavior; |
|
flClosestDist2 = flDist2; |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Set the closest NPC as controller. |
|
if ( pClosestNPC ) |
|
{ |
|
m_hController = pClosestNPC; |
|
pClosestBehavior->SetFuncTank( this ); |
|
NPC_SetInRoute( true ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Draw any debug text overlays |
|
// Output : Current text offset from the top |
|
//----------------------------------------------------------------------------- |
|
int CFuncTank::DrawDebugTextOverlays(void) |
|
{ |
|
int text_offset = BaseClass::DrawDebugTextOverlays(); |
|
|
|
if (m_debugOverlays & OVERLAY_TEXT_BIT) |
|
{ |
|
// -------------- |
|
// State |
|
// -------------- |
|
char tempstr[255]; |
|
if (IsActive()) |
|
{ |
|
Q_strncpy(tempstr,"State: Active",sizeof(tempstr)); |
|
} |
|
else |
|
{ |
|
Q_strncpy(tempstr,"State: Inactive",sizeof(tempstr)); |
|
} |
|
EntityText(text_offset,tempstr,0); |
|
text_offset++; |
|
|
|
// ------------------- |
|
// Print Firing Speed |
|
// -------------------- |
|
Q_snprintf(tempstr,sizeof(tempstr),"Fire Rate: %f",m_fireRate); |
|
|
|
EntityText(text_offset,tempstr,0); |
|
text_offset++; |
|
|
|
// -------------- |
|
// Print Target |
|
// -------------- |
|
if (m_hTarget!=NULL) |
|
{ |
|
Q_snprintf(tempstr,sizeof(tempstr),"Target: %s",m_hTarget->GetDebugName()); |
|
} |
|
else |
|
{ |
|
Q_snprintf(tempstr,sizeof(tempstr),"Target: - "); |
|
} |
|
EntityText(text_offset,tempstr,0); |
|
text_offset++; |
|
|
|
// -------------- |
|
// Target Pos |
|
// -------------- |
|
if (m_spawnflags & SF_TANK_AIM_AT_POS) |
|
{ |
|
Q_snprintf(tempstr,sizeof(tempstr),"Aim Pos: %3.0f %3.0f %3.0f",m_vTargetPosition.x,m_vTargetPosition.y,m_vTargetPosition.z); |
|
} |
|
else |
|
{ |
|
Q_snprintf(tempstr,sizeof(tempstr),"Aim Pos: - "); |
|
} |
|
EntityText(text_offset,tempstr,0); |
|
text_offset++; |
|
|
|
} |
|
return text_offset; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Override base class to add display of fly direction |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::DrawDebugGeometryOverlays(void) |
|
{ |
|
// Center |
|
QAngle angCenter; |
|
Vector vecForward; |
|
angCenter = QAngle( 0, YawCenterWorld(), 0 ); |
|
AngleVectors( angCenter, &vecForward ); |
|
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + (vecForward * 64), 255,255,255, true, 0.1); |
|
|
|
// Draw the yaw ranges |
|
angCenter = QAngle( 0, YawCenterWorld() + m_yawRange, 0 ); |
|
AngleVectors( angCenter, &vecForward ); |
|
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + (vecForward * 128), 0,255,0, true, 0.1); |
|
angCenter = QAngle( 0, YawCenterWorld() - m_yawRange, 0 ); |
|
AngleVectors( angCenter, &vecForward ); |
|
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + (vecForward * 128), 0,255,0, true, 0.1); |
|
|
|
// Draw the pitch ranges |
|
angCenter = QAngle( PitchCenterWorld() + m_pitchRange, 0, 0 ); |
|
AngleVectors( angCenter, &vecForward ); |
|
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + (vecForward * 128), 255,0,0, true, 0.1); |
|
angCenter = QAngle( PitchCenterWorld() - m_pitchRange, 0, 0 ); |
|
AngleVectors( angCenter, &vecForward ); |
|
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + (vecForward * 128), 255,0,0, true, 0.1); |
|
|
|
BaseClass::DrawDebugGeometryOverlays(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : pAttacker - |
|
// flDamage - |
|
// vecDir - |
|
// ptr - |
|
// bitsDamageType - |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::TraceAttack( CBaseEntity *pAttacker, float flDamage, const Vector &vecDir, trace_t *ptr, int bitsDamageType) |
|
{ |
|
if (m_spawnflags & SF_TANK_DAMAGE_KICK) |
|
{ |
|
// Deflect the func_tank |
|
// Only adjust yaw for now |
|
if (pAttacker) |
|
{ |
|
Vector vFromAttacker = (pAttacker->EyePosition()-GetAbsOrigin()); |
|
vFromAttacker.z = 0; |
|
VectorNormalize(vFromAttacker); |
|
|
|
Vector vFromAttacker2 = (ptr->endpos-GetAbsOrigin()); |
|
vFromAttacker2.z = 0; |
|
VectorNormalize(vFromAttacker2); |
|
|
|
|
|
Vector vCrossProduct; |
|
CrossProduct(vFromAttacker,vFromAttacker2, vCrossProduct); |
|
|
|
QAngle angles; |
|
angles = GetLocalAngles(); |
|
if (vCrossProduct.z > 0) |
|
{ |
|
angles.y += 10; |
|
} |
|
else |
|
{ |
|
angles.y -= 10; |
|
} |
|
|
|
// Limit against range in y |
|
if ( angles.y > m_yawCenter + m_yawRange ) |
|
{ |
|
angles.y = m_yawCenter + m_yawRange; |
|
} |
|
else if ( angles.y < (m_yawCenter - m_yawRange) ) |
|
{ |
|
angles.y = (m_yawCenter - m_yawRange); |
|
} |
|
|
|
SetLocalAngles( angles ); |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : targetName - |
|
// pActivator - |
|
//----------------------------------------------------------------------------- |
|
CBaseEntity *CFuncTank::FindTarget( string_t targetName, CBaseEntity *pActivator ) |
|
{ |
|
return gEntList.FindEntityGenericNearest( STRING( targetName ), GetAbsOrigin(), 0, this, pActivator ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Caches entity key values until spawn is called. |
|
// Input : szKeyName - |
|
// szValue - |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
bool CFuncTank::KeyValue( const char *szKeyName, const char *szValue ) |
|
{ |
|
if (FStrEq(szKeyName, "barrel")) |
|
{ |
|
m_barrelPos.x = atof(szValue); |
|
return true; |
|
} |
|
|
|
if (FStrEq(szKeyName, "barrely")) |
|
{ |
|
m_barrelPos.y = atof(szValue); |
|
return true; |
|
} |
|
|
|
if (FStrEq(szKeyName, "barrelz")) |
|
{ |
|
m_barrelPos.z = atof(szValue); |
|
return true; |
|
} |
|
|
|
return BaseClass::KeyValue( szKeyName, szValue ); |
|
} |
|
|
|
|
|
static Vector gTankSpread[] = |
|
{ |
|
Vector( 0, 0, 0 ), // perfect |
|
Vector( 0.025, 0.025, 0.025 ), // small cone |
|
Vector( 0.05, 0.05, 0.05 ), // medium cone |
|
Vector( 0.1, 0.1, 0.1 ), // large cone |
|
Vector( 0.25, 0.25, 0.25 ), // extra-large cone |
|
}; |
|
#define MAX_FIRING_SPREADS ARRAYSIZE(gTankSpread) |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::Spawn( void ) |
|
{ |
|
Precache(); |
|
|
|
#ifdef HL2_EPISODIC |
|
m_iAmmoType = GetAmmoDef()->Index( STRING( m_iszAmmoType ) ); |
|
#else |
|
m_iSmallAmmoType = GetAmmoDef()->Index("Pistol"); |
|
m_iMediumAmmoType = GetAmmoDef()->Index("SMG1"); |
|
m_iLargeAmmoType = GetAmmoDef()->Index("AR2"); |
|
#endif // HL2_EPISODIC |
|
|
|
SetMoveType( MOVETYPE_PUSH ); // so it doesn't get pushed by anything |
|
SetSolid( SOLID_VPHYSICS ); |
|
SetModel( STRING( GetModelName() ) ); |
|
AddEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID ); |
|
|
|
if ( HasSpawnFlags(SF_TANK_NOTSOLID) ) |
|
{ |
|
AddSolidFlags( FSOLID_NOT_SOLID ); |
|
} |
|
|
|
m_hControlVolume = NULL; |
|
|
|
if ( GetParent() && GetParent()->GetBaseAnimating() ) |
|
{ |
|
CBaseAnimating *pAnim = GetParent()->GetBaseAnimating(); |
|
if ( m_iszBaseAttachment != NULL_STRING ) |
|
{ |
|
int nAttachment = pAnim->LookupAttachment( STRING( m_iszBaseAttachment ) ); |
|
if ( nAttachment != 0 ) |
|
{ |
|
SetParent( pAnim, nAttachment ); |
|
SetLocalOrigin( vec3_origin ); |
|
SetLocalAngles( vec3_angle ); |
|
} |
|
} |
|
|
|
m_bUsePoseParameters = (m_iszYawPoseParam != NULL_STRING) && (m_iszPitchPoseParam != NULL_STRING); |
|
|
|
if ( m_iszBarrelAttachment != NULL_STRING ) |
|
{ |
|
if ( m_bUsePoseParameters ) |
|
{ |
|
pAnim->SetPoseParameter( STRING( m_iszYawPoseParam ), 0 ); |
|
pAnim->SetPoseParameter( STRING( m_iszPitchPoseParam ), 0 ); |
|
pAnim->InvalidateBoneCache(); |
|
} |
|
|
|
m_nBarrelAttachment = pAnim->LookupAttachment( STRING(m_iszBarrelAttachment) ); |
|
|
|
Vector vecWorldBarrelPos; |
|
QAngle worldBarrelAngle; |
|
pAnim->GetAttachment( m_nBarrelAttachment, vecWorldBarrelPos, worldBarrelAngle ); |
|
VectorITransform( vecWorldBarrelPos, EntityToWorldTransform( ), m_barrelPos ); |
|
} |
|
|
|
if ( m_bUsePoseParameters ) |
|
{ |
|
// In this case, we're relying on the parent to have the gun model |
|
AddEffects( EF_NODRAW ); |
|
QAngle localAngles( m_flPitchPoseCenter, m_flYawPoseCenter, 0 ); |
|
SetLocalAngles( localAngles ); |
|
SetSolid( SOLID_NONE ); |
|
SetMoveType( MOVETYPE_NOCLIP ); |
|
|
|
// If our parent is a prop_dynamic, make it use hitboxes for renderbox |
|
CDynamicProp *pProp = dynamic_cast<CDynamicProp*>(GetParent()); |
|
if ( pProp ) |
|
{ |
|
pProp->m_bUseHitboxesForRenderBox = true; |
|
} |
|
} |
|
} |
|
|
|
// For smoothing out leading |
|
m_flStartLeadFactor = 1.0f; |
|
m_flNextLeadFactor = 1.0f; |
|
m_flStartLeadFactorTime = gpGlobals->curtime; |
|
m_flNextLeadFactorTime = gpGlobals->curtime + 1.0f; |
|
|
|
m_yawCenter = GetLocalAngles().y; |
|
m_yawCenterWorld = GetAbsAngles().y; |
|
m_pitchCenter = GetLocalAngles().x; |
|
m_pitchCenterWorld = GetAbsAngles().y; |
|
m_vTargetPosition = vec3_origin; |
|
|
|
if ( IsActive() || (IsControllable() && !HasController()) ) |
|
{ |
|
// Think to find controllers. |
|
SetNextThink( gpGlobals->curtime + 1.0f ); |
|
m_flNextControllerSearch = gpGlobals->curtime + 1.0f; |
|
} |
|
|
|
UpdateMatrix(); |
|
|
|
m_sightOrigin = WorldBarrelPosition(); // Point at the end of the barrel |
|
|
|
if ( m_spread > MAX_FIRING_SPREADS ) |
|
{ |
|
m_spread = 0; |
|
} |
|
|
|
// No longer aim at target position if have one |
|
m_spawnflags &= ~SF_TANK_AIM_AT_POS; |
|
|
|
if (m_spawnflags & SF_TANK_DAMAGE_KICK) |
|
{ |
|
m_takedamage = DAMAGE_YES; |
|
} |
|
|
|
// UNDONE: Do this? |
|
//m_targetEntityName = m_target; |
|
if ( GetSolid() != SOLID_NONE ) |
|
{ |
|
CreateVPhysics(); |
|
} |
|
|
|
// Setup squared min/max range. |
|
m_flMinRange2 = m_minRange * m_minRange; |
|
m_flMaxRange2 = m_maxRange * m_maxRange; |
|
m_flIgnoreGraceUpto *= m_flIgnoreGraceUpto; |
|
|
|
m_flLastSawNonPlayer = 0; |
|
|
|
if( IsActive() ) |
|
{ |
|
m_OnReadyToFire.FireOutput( this, this ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::Activate( void ) |
|
{ |
|
BaseClass::Activate(); |
|
|
|
// Necessary for save/load |
|
if ( (m_iszBarrelAttachment != NULL_STRING) && (m_nBarrelAttachment == 0) ) |
|
{ |
|
if ( GetParent() && GetParent()->GetBaseAnimating() ) |
|
{ |
|
CBaseAnimating *pAnim = GetParent()->GetBaseAnimating(); |
|
m_nBarrelAttachment = pAnim->LookupAttachment( STRING(m_iszBarrelAttachment) ); |
|
} |
|
} |
|
} |
|
|
|
bool CFuncTank::CreateVPhysics() |
|
{ |
|
VPhysicsInitShadow( false, false ); |
|
return true; |
|
} |
|
|
|
|
|
void CFuncTank::Precache( void ) |
|
{ |
|
if ( m_iszSpriteSmoke != NULL_STRING ) |
|
PrecacheModel( STRING(m_iszSpriteSmoke) ); |
|
if ( m_iszSpriteFlash != NULL_STRING ) |
|
PrecacheModel( STRING(m_iszSpriteFlash) ); |
|
|
|
if ( m_soundStartRotate != NULL_STRING ) |
|
PrecacheScriptSound( STRING(m_soundStartRotate) ); |
|
if ( m_soundStopRotate != NULL_STRING ) |
|
PrecacheScriptSound( STRING(m_soundStopRotate) ); |
|
if ( m_soundLoopRotate != NULL_STRING ) |
|
PrecacheScriptSound( STRING(m_soundLoopRotate) ); |
|
|
|
PrecacheScriptSound( "Func_Tank.BeginUse" ); |
|
|
|
// Precache the combine cannon |
|
if ( m_iEffectHandling == EH_COMBINE_CANNON ) |
|
{ |
|
PrecacheScriptSound( "NPC_Combine_Cannon.FireBullet" ); |
|
} |
|
} |
|
|
|
void CFuncTank::UpdateOnRemove( void ) |
|
{ |
|
if ( HasController() ) |
|
{ |
|
StopControl(); |
|
} |
|
BaseClass::UpdateOnRemove(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Barrel position |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::UpdateMatrix( void ) |
|
{ |
|
m_parentMatrix.InitFromEntity( GetParent(), GetParentAttachment() ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Barrel position |
|
//----------------------------------------------------------------------------- |
|
Vector CFuncTank::WorldBarrelPosition( void ) |
|
{ |
|
if ( (m_nBarrelAttachment == 0) || !GetParent() ) |
|
{ |
|
EntityMatrix tmp; |
|
tmp.InitFromEntity( this ); |
|
return tmp.LocalToWorld( m_barrelPos ); |
|
} |
|
|
|
Vector vecOrigin; |
|
QAngle vecAngles; |
|
CBaseAnimating *pAnim = GetParent()->GetBaseAnimating(); |
|
pAnim->GetAttachment( m_nBarrelAttachment, vecOrigin, vecAngles ); |
|
return vecOrigin; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Make the parent's pose parameters match the func_tank |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::PhysicsSimulate( void ) |
|
{ |
|
BaseClass::PhysicsSimulate(); |
|
|
|
if ( m_bUsePoseParameters && GetParent() ) |
|
{ |
|
const QAngle &angles = GetLocalAngles(); |
|
CBaseAnimating *pAnim = GetParent()->GetBaseAnimating(); |
|
pAnim->SetPoseParameter( STRING( m_iszYawPoseParam ), angles.y ); |
|
pAnim->SetPoseParameter( STRING( m_iszPitchPoseParam ), angles.x ); |
|
pAnim->StudioFrameAdvance(); |
|
} |
|
} |
|
|
|
//============================================================================= |
|
// |
|
// TANK CONTROLLING |
|
// |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CFuncTank::OnControls( CBaseEntity *pTest ) |
|
{ |
|
// Is the tank controllable. |
|
if ( !IsControllable() ) |
|
return false; |
|
|
|
if ( !m_hControlVolume ) |
|
{ |
|
// Find our control volume |
|
if ( m_iszControlVolume != NULL_STRING ) |
|
{ |
|
m_hControlVolume = dynamic_cast<CBaseTrigger*>( gEntList.FindEntityByName( NULL, m_iszControlVolume ) ); |
|
} |
|
|
|
if (( !m_hControlVolume ) && IsControllable() ) |
|
{ |
|
Msg( "ERROR: Couldn't find control volume for player-controllable func_tank %s.\n", STRING(GetEntityName()) ); |
|
return false; |
|
} |
|
} |
|
|
|
if ( m_hControlVolume->IsTouching( pTest ) ) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CFuncTank::StartControl( CBaseCombatCharacter *pController ) |
|
{ |
|
// Check to see if we have a controller. |
|
if ( HasController() && GetController() != pController ) |
|
return false; |
|
|
|
// Team only or disabled? |
|
if ( m_iszMaster != NULL_STRING ) |
|
{ |
|
if ( !UTIL_IsMasterTriggered( m_iszMaster, pController ) ) |
|
return false; |
|
} |
|
|
|
// Set func_tank as manned by player/npc. |
|
m_hController = pController; |
|
if ( pController->IsPlayer() ) |
|
{ |
|
m_spawnflags |= SF_TANK_PLAYER; |
|
|
|
CBasePlayer *pPlayer = static_cast<CBasePlayer*>( m_hController.Get() ); |
|
pPlayer->m_Local.m_iHideHUD |= HIDEHUD_WEAPONSELECTION; |
|
} |
|
else |
|
{ |
|
m_spawnflags |= SF_TANK_NPC; |
|
NPC_SetInRoute( false ); |
|
} |
|
|
|
// Holster player/npc weapon |
|
if ( m_hController->GetActiveWeapon() ) |
|
{ |
|
m_hController->GetActiveWeapon()->Holster(); |
|
} |
|
|
|
// Set the controller's position to be the use position. |
|
m_vecControllerUsePos = m_hController->GetLocalOrigin(); |
|
|
|
EmitSound( "Func_Tank.BeginUse" ); |
|
|
|
SetNextThink( gpGlobals->curtime + 0.1f ); |
|
|
|
// Let the map maker know a controller has been found |
|
if ( m_hController->IsPlayer() ) |
|
{ |
|
m_OnGotPlayerController.FireOutput( this, this ); |
|
} |
|
else |
|
{ |
|
m_OnGotController.FireOutput( this, this ); |
|
} |
|
|
|
OnStartControlled(); |
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// TODO: bring back the controllers current weapon |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::StopControl() |
|
{ |
|
// Do we have a controller? |
|
if ( !m_hController ) |
|
return; |
|
|
|
OnStopControlled(); |
|
|
|
// Arm player/npc weapon. |
|
if ( m_hController->GetActiveWeapon() ) |
|
{ |
|
m_hController->GetActiveWeapon()->Deploy(); |
|
} |
|
|
|
if ( m_hController->IsPlayer() ) |
|
{ |
|
CBasePlayer *pPlayer = static_cast<CBasePlayer*>( m_hController.Get() ); |
|
pPlayer->m_Local.m_iHideHUD &= ~HIDEHUD_WEAPONSELECTION; |
|
} |
|
|
|
// Stop thinking. |
|
SetNextThink( TICK_NEVER_THINK ); |
|
|
|
// Let the map maker know a controller has been lost. |
|
if ( m_hController->IsPlayer() ) |
|
{ |
|
m_OnLostPlayerController.FireOutput( this, this ); |
|
} |
|
else |
|
{ |
|
m_OnLostController.FireOutput( this, this ); |
|
} |
|
|
|
// Reset the func_tank as unmanned (player/npc). |
|
if ( m_hController->IsPlayer() ) |
|
{ |
|
m_spawnflags &= ~SF_TANK_PLAYER; |
|
} |
|
else |
|
{ |
|
m_spawnflags &= ~SF_TANK_NPC; |
|
} |
|
|
|
m_hController = NULL; |
|
|
|
// Set think, if the func_tank can think on its own. |
|
if ( IsActive() || (IsControllable() && !HasController()) ) |
|
{ |
|
// Delay the think to find controllers a bit |
|
#ifdef FUNCTANK_AUTOUSE |
|
m_flNextControllerSearch = gpGlobals->curtime + 1.0f; |
|
#else |
|
m_flNextControllerSearch = gpGlobals->curtime + 5.0f; |
|
#endif//FUNCTANK_AUTOUSE |
|
|
|
SetNextThink( m_flNextControllerSearch ); |
|
} |
|
|
|
SetLocalAngularVelocity( vec3_angle ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Called each frame by the player's ItemPostFrame |
|
//----------------------------------------------------------------------------- |
|
|
|
// NVNT turret recoil |
|
ConVar hap_turret_mag("hap_turret_mag", "5", 0); |
|
|
|
void CFuncTank::ControllerPostFrame( void ) |
|
{ |
|
// Make sure we have a contoller. |
|
Assert( m_hController != NULL ); |
|
|
|
// Control the firing rate. |
|
if ( gpGlobals->curtime < m_flNextAttack ) |
|
return; |
|
|
|
if ( !IsPlayerManned() ) |
|
return; |
|
|
|
CBasePlayer *pPlayer = static_cast<CBasePlayer*>( m_hController.Get() ); |
|
if ( ( pPlayer->m_nButtons & IN_ATTACK ) == 0 ) |
|
return; |
|
|
|
Vector forward; |
|
AngleVectors( GetAbsAngles(), &forward ); |
|
m_fireLast = gpGlobals->curtime - (1/m_fireRate) - 0.01; // to make sure the gun doesn't fire too many bullets |
|
|
|
int bulletCount = (gpGlobals->curtime - m_fireLast) * m_fireRate; |
|
|
|
if( HasSpawnFlags( SF_TANK_AIM_ASSISTANCE ) ) |
|
{ |
|
// Trace out a hull and if it hits something, adjust the shot to hit that thing. |
|
trace_t tr; |
|
Vector start = WorldBarrelPosition(); |
|
Vector dir = forward; |
|
|
|
UTIL_TraceHull( start, start + forward * 8192, -Vector(8,8,8), Vector(8,8,8), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr ); |
|
|
|
if( tr.m_pEnt && tr.m_pEnt->m_takedamage != DAMAGE_NO && (tr.m_pEnt->GetFlags() & FL_AIMTARGET) ) |
|
{ |
|
forward = tr.m_pEnt->WorldSpaceCenter() - start; |
|
VectorNormalize( forward ); |
|
} |
|
} |
|
|
|
Fire( bulletCount, WorldBarrelPosition(), forward, pPlayer, false ); |
|
|
|
#if defined( WIN32 ) && !defined( _X360 ) |
|
// NVNT apply a punch on the player each time fired |
|
HapticPunch(pPlayer,0,0,hap_turret_mag.GetFloat()); |
|
#endif |
|
// HACKHACK -- make some noise (that the AI can hear) |
|
CSoundEnt::InsertSound( SOUND_COMBAT, WorldSpaceCenter(), FUNCTANK_FIREVOLUME, 0.2 ); |
|
|
|
if( m_iAmmoCount > -1 ) |
|
{ |
|
if( !(m_iAmmoCount % 10) ) |
|
{ |
|
Msg("Ammo Remaining: %d\n", m_iAmmoCount ); |
|
} |
|
|
|
if( --m_iAmmoCount == 0 ) |
|
{ |
|
// Kick the player off the gun, and make myself not usable. |
|
m_spawnflags &= ~SF_TANK_CANCONTROL; |
|
StopControl(); |
|
return; |
|
} |
|
} |
|
|
|
SetNextAttack( gpGlobals->curtime + (1/m_fireRate) ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CFuncTank::HasController( void ) |
|
{ |
|
return (m_hController != NULL); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : CBaseCombatCharacter |
|
//----------------------------------------------------------------------------- |
|
CBaseCombatCharacter *CFuncTank::GetController( void ) |
|
{ |
|
return m_hController; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CFuncTank::NPC_FindManPoint( Vector &vecPos ) |
|
{ |
|
if ( m_iszNPCManPoint != NULL_STRING ) |
|
{ |
|
CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, m_iszNPCManPoint ); |
|
if ( pEntity ) |
|
{ |
|
vecPos = pEntity->GetAbsOrigin(); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: The NPC manning this gun just saw a player for the first time since he left cover |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::NPC_JustSawPlayer( CBaseEntity *pTarget ) |
|
{ |
|
SetNextAttack( gpGlobals->curtime + m_flPlayerLockTimeBeforeFire ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::NPC_Fire( void ) |
|
{ |
|
// Control the firing rate. |
|
if ( gpGlobals->curtime < m_flNextAttack ) |
|
return; |
|
|
|
// Check for a valid npc controller. |
|
if ( !m_hController ) |
|
return; |
|
|
|
CAI_BaseNPC *pNPC = m_hController->MyNPCPointer(); |
|
if ( !pNPC ) |
|
return; |
|
|
|
// Setup for next round of firing. |
|
if ( m_nBulletCount == 0 ) |
|
{ |
|
m_nBulletCount = GetRandomBurst(); |
|
m_fireTime = 1.0f; |
|
} |
|
|
|
// m_fireLast looks like it is only needed for Active non-controlled func_tank. |
|
// m_fireLast = gpGlobals->curtime - (1/m_fireRate) - 0.01; // to make sure the gun doesn't fire too many bullets |
|
|
|
Vector vecBarrelEnd = WorldBarrelPosition(); |
|
Vector vecForward; |
|
AngleVectors( GetAbsAngles(), &vecForward ); |
|
|
|
if ( (pNPC->CapabilitiesGet() & bits_CAP_NO_HIT_SQUADMATES) && pNPC->IsInSquad() ) |
|
{ |
|
// Avoid shooting squadmates. |
|
if ( pNPC->IsSquadmateInSpread( vecBarrelEnd, vecBarrelEnd + vecForward * 2048, gTankSpread[m_spread].x, 8*12 ) ) |
|
{ |
|
return; |
|
} |
|
} |
|
|
|
if ( !HasSpawnFlags( SF_TANK_ALLOW_PLAYER_HITS ) && (pNPC->CapabilitiesGet() & bits_CAP_NO_HIT_PLAYER) ) |
|
{ |
|
// Avoid shooting player. |
|
if ( pNPC->PlayerInSpread( vecBarrelEnd, vecBarrelEnd + vecForward * 2048, gTankSpread[m_spread].x, 8*12 ) ) |
|
{ |
|
return; |
|
} |
|
} |
|
|
|
bool bIgnoreSpread = false; |
|
|
|
CBaseEntity *pEnemy = pNPC->GetEnemy(); |
|
if ( HasSpawnFlags( SF_TANK_HACKPLAYERHIT ) && pEnemy && pEnemy->IsPlayer() ) |
|
{ |
|
// Every third shot should be fired directly at the player |
|
if ( m_nBulletCount%2 == 0 ) |
|
{ |
|
Vector vecBodyTarget = pEnemy->BodyTarget( vecBarrelEnd, false ); |
|
vecForward = (vecBodyTarget - vecBarrelEnd); |
|
VectorNormalize( vecForward ); |
|
bIgnoreSpread = true; |
|
} |
|
} |
|
|
|
// Fire the bullet(s). |
|
Fire( 1, vecBarrelEnd, vecForward, m_hController, bIgnoreSpread ); |
|
--m_nBulletCount; |
|
|
|
// Check ammo counts and dismount when empty. |
|
if( m_iAmmoCount > -1 ) |
|
{ |
|
if( --m_iAmmoCount == 0 ) |
|
{ |
|
// Disable the func_tank. |
|
m_spawnflags &= ~SF_TANK_CANCONTROL; |
|
|
|
// Remove the npc. |
|
StopControl(); |
|
return; |
|
} |
|
} |
|
|
|
float flFireTime = GetRandomFireTime(); |
|
if ( m_nBulletCount != 0 ) |
|
{ |
|
m_fireTime -= flFireTime; |
|
SetNextAttack( gpGlobals->curtime + flFireTime ); |
|
} |
|
else |
|
{ |
|
SetNextAttack( gpGlobals->curtime + m_fireTime ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CFuncTank::NPC_HasEnemy( void ) |
|
{ |
|
if ( !IsNPCManned() ) |
|
return false; |
|
|
|
CAI_BaseNPC *pNPC = m_hController->MyNPCPointer(); |
|
Assert( pNPC ); |
|
|
|
return ( pNPC->GetEnemy() != NULL ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::NPC_InterruptRoute( void ) |
|
{ |
|
if ( !m_hController ) |
|
return; |
|
|
|
CAI_BaseNPC *pNPC = m_hController->MyNPCPointer(); |
|
if ( !pNPC ) |
|
return; |
|
|
|
CAI_FuncTankBehavior *pBehavior; |
|
if ( pNPC->GetBehavior( &pBehavior ) ) |
|
{ |
|
pBehavior->SetFuncTank( NULL ); |
|
} |
|
|
|
// Reset the npc controller. |
|
m_hController = NULL; |
|
|
|
// No NPC's in route. |
|
NPC_SetInRoute( false ); |
|
|
|
// Delay the think to find controllers a bit |
|
m_flNextControllerSearch = gpGlobals->curtime + 5.0f; |
|
|
|
if ( !HasController() ) |
|
{ |
|
// Start thinking to find controllers again |
|
SetNextThink( m_flNextControllerSearch ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CFuncTank::NPC_InterruptController( void ) |
|
{ |
|
// If we don't have a controller - then the gun should be free. |
|
if ( !m_hController ) |
|
return true; |
|
|
|
CAI_BaseNPC *pNPC = m_hController->MyNPCPointer(); |
|
if ( !pNPC || !pNPC->IsPlayerAlly() ) |
|
return false; |
|
|
|
CAI_FuncTankBehavior *pBehavior; |
|
if ( pNPC->GetBehavior( &pBehavior ) ) |
|
{ |
|
pBehavior->Dismount(); |
|
} |
|
|
|
m_hController = NULL; |
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : float |
|
//----------------------------------------------------------------------------- |
|
float CFuncTank::GetRandomFireTime( void ) |
|
{ |
|
Assert( m_fireRate != 0 ); |
|
float flOOFireRate = 1.0f / m_fireRate; |
|
float flOOFireRateBy2 = flOOFireRate * 0.5f; |
|
float flOOFireRateBy4 = flOOFireRate * 0.25f; |
|
return random->RandomFloat( flOOFireRateBy4, flOOFireRateBy2 ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : int |
|
//----------------------------------------------------------------------------- |
|
int CFuncTank::GetRandomBurst( void ) |
|
{ |
|
return random->RandomInt( m_fireRate-2, m_fireRate+2 ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *pActivator - |
|
// *pCaller - |
|
// useType - |
|
// value - |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) |
|
{ |
|
if ( !IsControllable() ) |
|
return; |
|
|
|
// player controlled turret |
|
CBasePlayer *pPlayer = ToBasePlayer( pActivator ); |
|
if ( !pPlayer ) |
|
return; |
|
|
|
if ( value == 2 && useType == USE_SET ) |
|
{ |
|
ControllerPostFrame(); |
|
} |
|
else if ( m_hController != pPlayer && useType != USE_OFF ) |
|
{ |
|
// The player must be within the func_tank controls |
|
if ( !m_hControlVolume ) |
|
{ |
|
// Find our control volume |
|
if ( m_iszControlVolume != NULL_STRING ) |
|
{ |
|
m_hControlVolume = dynamic_cast<CBaseTrigger*>( gEntList.FindEntityByName( NULL, m_iszControlVolume ) ); |
|
} |
|
|
|
if (( !m_hControlVolume ) && IsControllable() ) |
|
{ |
|
Msg( "ERROR: Couldn't find control volume for player-controllable func_tank %s.\n", STRING(GetEntityName()) ); |
|
return; |
|
} |
|
} |
|
|
|
if ( !m_hControlVolume->IsTouching( pPlayer ) ) |
|
return; |
|
|
|
// Interrupt any npc in route (ally or not). |
|
if ( NPC_InRoute() ) |
|
{ |
|
// Interrupt the npc's route. |
|
NPC_InterruptRoute(); |
|
} |
|
|
|
// Interrupt NPC - if possible (they must be allies). |
|
if ( IsNPCControllable() && HasController() ) |
|
{ |
|
if ( !NPC_InterruptController() ) |
|
return; |
|
} |
|
|
|
pPlayer->SetUseEntity( this ); |
|
StartControl( pPlayer ); |
|
} |
|
else |
|
{ |
|
StopControl(); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : range - |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CFuncTank::InRange( float range ) |
|
{ |
|
if ( range < m_minRange ) |
|
return FALSE; |
|
if ( (m_maxRange > 0) && (range > m_maxRange) ) |
|
return FALSE; |
|
|
|
return TRUE; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CFuncTank::InRange2( float flRange2 ) |
|
{ |
|
if ( flRange2 < m_flMinRange2 ) |
|
return false; |
|
|
|
if ( ( m_flMaxRange2 > 0.0f ) && ( flRange2 > m_flMaxRange2 ) ) |
|
return false; |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::Think( void ) |
|
{ |
|
FuncTankPreThink(); |
|
|
|
m_hFuncTankTarget = NULL; |
|
|
|
// Look for a new controller? |
|
if ( IsControllable() && !HasController() && (m_flNextControllerSearch <= gpGlobals->curtime) ) |
|
{ |
|
if ( m_bShouldFindNPCs && gpGlobals->curtime > 5.0f ) |
|
{ |
|
// Check for in route and timer. |
|
if ( !NPC_InRoute() ) |
|
{ |
|
NPC_FindController(); |
|
} |
|
} |
|
|
|
#ifdef FUNCTANK_AUTOUSE |
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex(1); |
|
bool bThinkFast = false; |
|
|
|
if( pPlayer ) |
|
{ |
|
if ( !m_hControlVolume ) |
|
{ |
|
// Find our control volume |
|
if ( m_iszControlVolume != NULL_STRING ) |
|
{ |
|
m_hControlVolume = dynamic_cast<CBaseTrigger*>( gEntList.FindEntityByName( NULL, m_iszControlVolume ) ); |
|
} |
|
|
|
if (( !m_hControlVolume ) && IsControllable() ) |
|
{ |
|
Msg( "ERROR: Couldn't find control volume for player-controllable func_tank %s.\n", STRING(GetEntityName()) ); |
|
return; |
|
} |
|
} |
|
|
|
if ( m_hControlVolume ) |
|
{ |
|
if( m_hControlVolume->IsTouching( pPlayer ) && pPlayer->FInViewCone(WorldSpaceCenter()) ) |
|
{ |
|
// If my control volume is touching a player that's facing the mounted gun, automatically use the gun. |
|
// !!!BUGBUG - this only works in cases where the player can see the gun whilst standing in the control |
|
// volume. (This works just fine for all func_tanks mounted on combine walls and small barriers) |
|
variant_t emptyVariant; |
|
AcceptInput( "Use", pPlayer, pPlayer, emptyVariant, USE_TOGGLE ); |
|
} |
|
else |
|
{ |
|
// If the player is nearby, think faster for snappier response to XBox auto mounting |
|
float flDistSqr = GetAbsOrigin().DistToSqr( pPlayer->GetAbsOrigin() ); |
|
|
|
if( flDistSqr <= Square(360) ) |
|
{ |
|
bThinkFast = true; |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Keep thinking, in case they turn NPC finding back on |
|
if ( !HasController() ) |
|
{ |
|
if( bThinkFast ) |
|
{ |
|
SetNextThink( gpGlobals->curtime + 0.1f ); |
|
} |
|
else |
|
{ |
|
SetNextThink( gpGlobals->curtime + 2.0f ); |
|
} |
|
} |
|
|
|
if( bThinkFast ) |
|
{ |
|
m_flNextControllerSearch = gpGlobals->curtime + 0.1f; |
|
} |
|
else |
|
{ |
|
m_flNextControllerSearch = gpGlobals->curtime + 2.0f; |
|
} |
|
#else |
|
// Keep thinking, in case they turn NPC finding back on |
|
if ( !HasController() ) |
|
{ |
|
SetNextThink( gpGlobals->curtime + 2.0f ); |
|
} |
|
|
|
m_flNextControllerSearch = gpGlobals->curtime + 2.0f; |
|
#endif//FUNCTANK_AUTOUSE |
|
} |
|
|
|
// refresh the matrix |
|
UpdateMatrix(); |
|
|
|
SetLocalAngularVelocity( vec3_angle ); |
|
TrackTarget(); |
|
|
|
if ( fabs(GetLocalAngularVelocity().x) > 1 || fabs(GetLocalAngularVelocity().y) > 1 ) |
|
{ |
|
StartRotSound(); |
|
} |
|
else |
|
{ |
|
StopRotSound(); |
|
} |
|
|
|
FuncTankPostThink(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Aim the offset barrel at a position in parent space |
|
// Input : parentTarget - the position of the target in parent space |
|
// Output : Vector - angles in local space |
|
//----------------------------------------------------------------------------- |
|
QAngle CFuncTank::AimBarrelAt( const Vector &parentTarget ) |
|
{ |
|
Vector target = parentTarget - GetLocalOrigin(); |
|
float quadTarget = target.LengthSqr(); |
|
float quadTargetXY = target.x*target.x + target.y*target.y; |
|
|
|
// Target is too close! Can't aim at it |
|
if ( quadTarget <= m_barrelPos.LengthSqr() ) |
|
{ |
|
return GetLocalAngles(); |
|
} |
|
else |
|
{ |
|
// We're trying to aim the offset barrel at an arbitrary point. |
|
// To calculate this, I think of the target as being on a sphere with |
|
// it's center at the origin of the gun. |
|
// The rotation we need is the opposite of the rotation that moves the target |
|
// along the surface of that sphere to intersect with the gun's shooting direction |
|
// To calculate that rotation, we simply calculate the intersection of the ray |
|
// coming out of the barrel with the target sphere (that's the new target position) |
|
// and use atan2() to get angles |
|
|
|
// angles from target pos to center |
|
float targetToCenterYaw = atan2( target.y, target.x ); |
|
float centerToGunYaw = atan2( m_barrelPos.y, sqrt( quadTarget - (m_barrelPos.y*m_barrelPos.y) ) ); |
|
|
|
float targetToCenterPitch = atan2( target.z, sqrt( quadTargetXY ) ); |
|
float centerToGunPitch = atan2( -m_barrelPos.z, sqrt( quadTarget - (m_barrelPos.z*m_barrelPos.z) ) ); |
|
return QAngle( -RAD2DEG(targetToCenterPitch+centerToGunPitch), RAD2DEG( targetToCenterYaw + centerToGunYaw ), 0 ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Aim the tank at the player crosshair |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::CalcPlayerCrosshairTarget( Vector *pVecTarget ) |
|
{ |
|
// Get the player. |
|
CBasePlayer *pPlayer = static_cast<CBasePlayer*>( m_hController.Get() ); |
|
|
|
// Tank aims at player's crosshair. |
|
Vector vecStart, vecDir; |
|
trace_t tr; |
|
|
|
vecStart = pPlayer->EyePosition(); |
|
|
|
if ( !IsX360() ) |
|
{ |
|
vecDir = pPlayer->EyeDirection3D(); |
|
} |
|
else |
|
{ |
|
// Use autoaim as the eye dir. |
|
vecDir = pPlayer->GetAutoaimVector( AUTOAIM_SCALE_DEFAULT ); |
|
} |
|
|
|
// Make sure to start the trace outside of the player's bbox! |
|
UTIL_TraceLine( vecStart + vecDir * 24, vecStart + vecDir * 8192, MASK_BLOCKLOS_AND_NPCS, this, COLLISION_GROUP_NONE, &tr ); |
|
|
|
*pVecTarget = tr.endpos; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Aim the tank at the player crosshair |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::AimBarrelAtPlayerCrosshair( QAngle *pAngles ) |
|
{ |
|
Vector vecTarget; |
|
CalcPlayerCrosshairTarget( &vecTarget ); |
|
*pAngles = AimBarrelAt( m_parentMatrix.WorldToLocal( vecTarget ) ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Aim the tank at the NPC's enemy |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::CalcNPCEnemyTarget( Vector *pVecTarget ) |
|
{ |
|
Vector vecTarget; |
|
CAI_BaseNPC *pNPC = m_hController->MyNPCPointer(); |
|
|
|
// Aim the barrel at the npc's enemy, or where the npc is looking. |
|
CBaseEntity *pEnemy = pNPC->GetEnemy(); |
|
if ( pEnemy ) |
|
{ |
|
// Clear the idle target |
|
*pVecTarget = pEnemy->BodyTarget( GetAbsOrigin(), false ); |
|
m_vecNPCIdleTarget = *pVecTarget; |
|
} |
|
else |
|
{ |
|
if ( m_vecNPCIdleTarget != vec3_origin ) |
|
{ |
|
*pVecTarget = m_vecNPCIdleTarget; |
|
} |
|
else |
|
{ |
|
Vector vecForward; |
|
QAngle angCenter( 0, m_yawCenterWorld, 0 ); |
|
AngleVectors( angCenter, &vecForward ); |
|
trace_t tr; |
|
Vector vecBarrel = GetAbsOrigin() + m_barrelPos; |
|
UTIL_TraceLine( vecBarrel, vecBarrel + vecForward * 8192, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr ); |
|
*pVecTarget = tr.endpos; |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Aim the tank at the NPC's enemy |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::AimBarrelAtNPCEnemy( QAngle *pAngles ) |
|
{ |
|
Vector vecTarget; |
|
CalcNPCEnemyTarget( &vecTarget ); |
|
*pAngles = AimBarrelAt( m_parentMatrix.WorldToLocal( vecTarget ) ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns true if the desired angles are out of range |
|
//----------------------------------------------------------------------------- |
|
bool CFuncTank::RotateTankToAngles( const QAngle &angles, float *pDistX, float *pDistY ) |
|
{ |
|
bool bClamped = false; |
|
|
|
// Force the angles to be relative to the center position |
|
float offsetY = UTIL_AngleDistance( angles.y, m_yawCenter ); |
|
float offsetX = UTIL_AngleDistance( angles.x, m_pitchCenter ); |
|
|
|
float flActualYaw = m_yawCenter + offsetY; |
|
float flActualPitch = m_pitchCenter + offsetX; |
|
|
|
if ( ( fabs( offsetY ) > m_yawRange + m_yawTolerance ) || |
|
( fabs( offsetX ) > m_pitchRange + m_pitchTolerance ) ) |
|
{ |
|
// Limit against range in x |
|
flActualYaw = clamp( flActualYaw, m_yawCenter - m_yawRange, m_yawCenter + m_yawRange ); |
|
flActualPitch = clamp( flActualPitch, m_pitchCenter - m_pitchRange, m_pitchCenter + m_pitchRange ); |
|
|
|
bClamped = true; |
|
} |
|
|
|
// Get at the angular vel |
|
QAngle vecAngVel = GetLocalAngularVelocity(); |
|
|
|
// Move toward target at rate or less |
|
float distY = UTIL_AngleDistance( flActualYaw, GetLocalAngles().y ); |
|
vecAngVel.y = distY * 10; |
|
vecAngVel.y = clamp( vecAngVel.y, -m_yawRate, m_yawRate ); |
|
|
|
// Move toward target at rate or less |
|
float distX = UTIL_AngleDistance( flActualPitch, GetLocalAngles().x ); |
|
vecAngVel.x = distX * 10; |
|
vecAngVel.x = clamp( vecAngVel.x, -m_pitchRate, m_pitchRate ); |
|
|
|
// How exciting! We're done |
|
SetLocalAngularVelocity( vecAngVel ); |
|
|
|
if ( pDistX && pDistY ) |
|
{ |
|
*pDistX = distX; |
|
*pDistY = distY; |
|
} |
|
|
|
return bClamped; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// We lost our target! |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::LostTarget( void ) |
|
{ |
|
if (m_fireLast != 0) |
|
{ |
|
m_OnLoseTarget.FireOutput(this, this); |
|
m_fireLast = 0; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::ComputeLeadingPosition( const Vector &vecShootPosition, CBaseEntity *pTarget, Vector *pLeadPosition ) |
|
{ |
|
Vector vecTarget = pTarget->BodyTarget( vecShootPosition, false ); |
|
float flShotSpeed = GetShotSpeed(); |
|
if ( flShotSpeed == 0 ) |
|
{ |
|
*pLeadPosition = vecTarget; |
|
return; |
|
} |
|
|
|
Vector vecVelocity = pTarget->GetSmoothedVelocity(); |
|
vecVelocity.z = 0.0f; |
|
float flTargetSpeed = VectorNormalize( vecVelocity ); |
|
|
|
// Guesstimate... |
|
if ( m_flNextLeadFactorTime < gpGlobals->curtime ) |
|
{ |
|
m_flStartLeadFactor = m_flNextLeadFactor; |
|
m_flStartLeadFactorTime = gpGlobals->curtime; |
|
m_flNextLeadFactor = random->RandomFloat( 0.8f, 1.3f ); |
|
m_flNextLeadFactorTime = gpGlobals->curtime + random->RandomFloat( 2.0f, 4.0f ); |
|
} |
|
|
|
float flFactor = (gpGlobals->curtime - m_flStartLeadFactorTime) / (m_flNextLeadFactorTime - m_flStartLeadFactorTime); |
|
float flLeadFactor = SimpleSplineRemapVal( flFactor, 0.0f, 1.0f, m_flStartLeadFactor, m_flNextLeadFactor ); |
|
flTargetSpeed *= flLeadFactor; |
|
|
|
Vector vecDelta; |
|
VectorSubtract( vecShootPosition, vecTarget, vecDelta ); |
|
float flTargetToShooter = VectorNormalize( vecDelta ); |
|
float flCosTheta = DotProduct( vecDelta, vecVelocity ); |
|
|
|
// Law of cosines... z^2 = x^2 + y^2 - 2xy cos Theta |
|
// where z = flShooterToPredictedTargetPosition = flShotSpeed * predicted time |
|
// x = flTargetSpeed * predicted time |
|
// y = flTargetToShooter |
|
// solve for predicted time using at^2 + bt + c = 0, t = (-b +/- sqrt( b^2 - 4ac )) / 2a |
|
float a = flTargetSpeed * flTargetSpeed - flShotSpeed * flShotSpeed; |
|
float b = -2.0f * flTargetToShooter * flCosTheta * flTargetSpeed; |
|
float c = flTargetToShooter * flTargetToShooter; |
|
|
|
float flDiscrim = b*b - 4*a*c; |
|
if (flDiscrim < 0) |
|
{ |
|
*pLeadPosition = vecTarget; |
|
return; |
|
} |
|
|
|
flDiscrim = sqrt(flDiscrim); |
|
float t = (-b + flDiscrim) / (2.0f * a); |
|
float t2 = (-b - flDiscrim) / (2.0f * a); |
|
if ( t < t2 ) |
|
{ |
|
t = t2; |
|
} |
|
|
|
if ( t <= 0.0f ) |
|
{ |
|
*pLeadPosition = vecTarget; |
|
return; |
|
} |
|
|
|
VectorMA( vecTarget, flTargetSpeed * t, vecVelocity, *pLeadPosition ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::AimFuncTankAtTarget( void ) |
|
{ |
|
// Get world target position |
|
CBaseEntity *pTarget = NULL; |
|
trace_t tr; |
|
QAngle angles; |
|
bool bUpdateTime = false; |
|
|
|
CBaseEntity *pTargetVehicle = NULL; |
|
Vector barrelEnd = WorldBarrelPosition(); |
|
Vector worldTargetPosition; |
|
if (m_spawnflags & SF_TANK_AIM_AT_POS) |
|
{ |
|
worldTargetPosition = m_vTargetPosition; |
|
} |
|
else |
|
{ |
|
CBaseEntity *pEntity = (CBaseEntity *)m_hTarget; |
|
if ( !pEntity || ( pEntity->GetFlags() & FL_NOTARGET ) ) |
|
{ |
|
if( m_targetEntityName != NULL_STRING ) |
|
{ |
|
m_hTarget = FindTarget( m_targetEntityName, NULL ); |
|
} |
|
|
|
LostTarget(); |
|
return; |
|
} |
|
|
|
pTarget = pEntity; |
|
|
|
// Calculate angle needed to aim at target |
|
worldTargetPosition = pEntity->EyePosition(); |
|
if ( pEntity->IsPlayer() ) |
|
{ |
|
CBasePlayer *pPlayer = assert_cast<CBasePlayer*>(pEntity); |
|
pTargetVehicle = pPlayer->GetVehicleEntity(); |
|
if ( pTargetVehicle ) |
|
{ |
|
worldTargetPosition = pTargetVehicle->BodyTarget( GetAbsOrigin(), false ); |
|
} |
|
} |
|
} |
|
|
|
float range2 = worldTargetPosition.DistToSqr( barrelEnd ); |
|
if ( !InRange2( range2 ) ) |
|
{ |
|
if ( m_hTarget ) |
|
{ |
|
m_hTarget = NULL; |
|
LostTarget(); |
|
} |
|
return; |
|
} |
|
|
|
Vector vecAimOrigin = m_sightOrigin; |
|
if (m_spawnflags & SF_TANK_AIM_AT_POS) |
|
{ |
|
bUpdateTime = true; |
|
m_sightOrigin = m_vTargetPosition; |
|
vecAimOrigin = m_sightOrigin; |
|
} |
|
else |
|
{ |
|
if ( m_spawnflags & SF_TANK_LINEOFSIGHT ) |
|
{ |
|
AI_TraceLOS( barrelEnd, worldTargetPosition, this, &tr ); |
|
} |
|
else |
|
{ |
|
tr.fraction = 1.0f; |
|
tr.m_pEnt = pTarget; |
|
} |
|
|
|
// No line of sight, don't track |
|
if ( tr.fraction == 1.0 || tr.m_pEnt == pTarget || (pTargetVehicle && (tr.m_pEnt == pTargetVehicle)) ) |
|
{ |
|
if ( InRange2( range2 ) && pTarget && pTarget->IsAlive() ) |
|
{ |
|
bUpdateTime = true; |
|
|
|
// Sight position is BodyTarget with no noise (so gun doesn't bob up and down) |
|
CBaseEntity *pInstance = pTargetVehicle ? pTargetVehicle : pTarget; |
|
m_hFuncTankTarget = pInstance; |
|
|
|
m_sightOrigin = pInstance->BodyTarget( GetAbsOrigin(), false ); |
|
if ( m_bPerformLeading ) |
|
{ |
|
ComputeLeadingPosition( barrelEnd, pInstance, &vecAimOrigin ); |
|
} |
|
else |
|
{ |
|
vecAimOrigin = m_sightOrigin; |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Convert targetPosition to parent |
|
Vector vecLocalOrigin = m_parentMatrix.WorldToLocal( vecAimOrigin ); |
|
angles = AimBarrelAt( vecLocalOrigin ); |
|
|
|
// FIXME: These need to be the clamped angles |
|
float distX, distY; |
|
bool bClamped = RotateTankToAngles( angles, &distX, &distY ); |
|
if ( bClamped ) |
|
{ |
|
bUpdateTime = false; |
|
} |
|
|
|
if ( bUpdateTime ) |
|
{ |
|
if( (gpGlobals->curtime - m_lastSightTime >= 1.0) && (gpGlobals->curtime > m_flNextAttack) ) |
|
{ |
|
// Enemy was hidden for a while, and I COULD fire right now. Instead, tack a delay on. |
|
m_flNextAttack = gpGlobals->curtime + 0.5; |
|
} |
|
|
|
m_lastSightTime = gpGlobals->curtime; |
|
m_persist2burst = 0; |
|
} |
|
|
|
SetMoveDoneTime( 0.1 ); |
|
|
|
if ( CanFire() && ( ( (fabs(distX) <= m_pitchTolerance) && (fabs(distY) <= m_yawTolerance) ) || (m_spawnflags & SF_TANK_LINEOFSIGHT) ) ) |
|
{ |
|
bool fire = false; |
|
Vector forward; |
|
AngleVectors( GetLocalAngles(), &forward ); |
|
forward = m_parentMatrix.ApplyRotation( forward ); |
|
|
|
if ( m_spawnflags & SF_TANK_LINEOFSIGHT ) |
|
{ |
|
AI_TraceLine( barrelEnd, pTarget->WorldSpaceCenter(), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr ); |
|
|
|
if ( tr.fraction == 1.0f || (tr.m_pEnt && tr.m_pEnt == pTarget) ) |
|
{ |
|
fire = true; |
|
} |
|
} |
|
else |
|
{ |
|
fire = true; |
|
} |
|
|
|
if ( fire ) |
|
{ |
|
if (m_fireLast == 0) |
|
{ |
|
m_OnAquireTarget.FireOutput(this, this); |
|
} |
|
FiringSequence( barrelEnd, forward, this ); |
|
} |
|
else |
|
{ |
|
LostTarget(); |
|
} |
|
} |
|
else |
|
{ |
|
LostTarget(); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::TrackTarget( void ) |
|
{ |
|
QAngle angles; |
|
|
|
if( !m_bReadyToFire && m_flNextAttack <= gpGlobals->curtime ) |
|
{ |
|
m_OnReadyToFire.FireOutput( this, this ); |
|
m_bReadyToFire = true; |
|
} |
|
|
|
if ( IsPlayerManned() ) |
|
{ |
|
AimBarrelAtPlayerCrosshair( &angles ); |
|
RotateTankToAngles( angles ); |
|
SetNextThink( gpGlobals->curtime + 0.05f ); |
|
SetMoveDoneTime( 0.1 ); |
|
return; |
|
} |
|
|
|
if ( IsNPCManned() ) |
|
{ |
|
AimBarrelAtNPCEnemy( &angles ); |
|
RotateTankToAngles( angles ); |
|
SetNextThink( gpGlobals->curtime + 0.05f ); |
|
SetMoveDoneTime( 0.1 ); |
|
return; |
|
} |
|
|
|
if ( !IsActive() ) |
|
{ |
|
// If we're not active, but we're controllable, we need to keep thinking |
|
if ( IsControllable() && !HasController() ) |
|
{ |
|
// Think to find controllers. |
|
SetNextThink( m_flNextControllerSearch ); |
|
} |
|
return; |
|
} |
|
|
|
// Clean room for unnecessarily complicated old code |
|
SetNextThink( gpGlobals->curtime + 0.1f ); |
|
AimFuncTankAtTarget(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Start of firing sequence. By default, just fire now. |
|
// Input : &barrelEnd - |
|
// &forward - |
|
// *pAttacker - |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::FiringSequence( const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker ) |
|
{ |
|
if ( m_fireLast != 0 ) |
|
{ |
|
int bulletCount = (gpGlobals->curtime - m_fireLast) * m_fireRate; |
|
|
|
if ( bulletCount > 0 ) |
|
{ |
|
// NOTE: Set m_fireLast first so that Fire can adjust it |
|
m_fireLast = gpGlobals->curtime; |
|
Fire( bulletCount, barrelEnd, forward, pAttacker, false ); |
|
} |
|
} |
|
else |
|
{ |
|
m_fireLast = gpGlobals->curtime; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::DoMuzzleFlash( void ) |
|
{ |
|
// If we're parented to something, make it play the muzzleflash |
|
if ( m_bUsePoseParameters && GetParent() ) |
|
{ |
|
CBaseAnimating *pAnim = GetParent()->GetBaseAnimating(); |
|
pAnim->DoMuzzleFlash(); |
|
|
|
// Do the AR2 muzzle flash |
|
if ( m_iEffectHandling == EH_COMBINE_CANNON ) |
|
{ |
|
CEffectData data; |
|
data.m_nAttachmentIndex = m_nBarrelAttachment; |
|
data.m_nEntIndex = pAnim->entindex(); |
|
|
|
// FIXME: Create a custom entry here! |
|
DispatchEffect( "ChopperMuzzleFlash", data ); |
|
} |
|
else |
|
{ |
|
CEffectData data; |
|
data.m_nEntIndex = pAnim->entindex(); |
|
data.m_nAttachmentIndex = m_nBarrelAttachment; |
|
data.m_flScale = 1.0f; |
|
data.m_fFlags = MUZZLEFLASH_COMBINE; |
|
|
|
DispatchEffect( "MuzzleFlash", data ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Output : const char |
|
//----------------------------------------------------------------------------- |
|
const char *CFuncTank::GetTracerType( void ) |
|
{ |
|
switch( m_iEffectHandling ) |
|
{ |
|
case EH_AR2: |
|
return "AR2Tracer"; |
|
|
|
case EH_COMBINE_CANNON: |
|
return "HelicopterTracer"; |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Fire targets and spawn sprites. |
|
// Input : bulletCount - |
|
// barrelEnd - |
|
// forward - |
|
// pAttacker - |
|
//----------------------------------------------------------------------------- |
|
void CFuncTank::Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ) |
|
{ |
|
// If we have a specific effect handler, apply it's effects |
|
if ( m_iEffectHandling == EH_AR2 ) |
|
{ |
|
DoMuzzleFlash(); |
|
|
|
// Play the AR2 sound |
|
EmitSound( "Weapon_functank.Single" ); |
|
} |
|
else if ( m_iEffectHandling == EH_COMBINE_CANNON ) |
|
{ |
|
DoMuzzleFlash(); |
|
|
|
// Play the cannon sound |
|
EmitSound( "NPC_Combine_Cannon.FireBullet" ); |
|
} |
|
else |
|
{ |
|
if ( m_iszSpriteSmoke != NULL_STRING ) |
|
{ |
|
CSprite *pSprite = CSprite::SpriteCreate( STRING(m_iszSpriteSmoke), barrelEnd, TRUE ); |
|
pSprite->AnimateAndDie( random->RandomFloat( 15.0, 20.0 ) ); |
|
pSprite->SetTransparency( kRenderTransAlpha, m_clrRender->r, m_clrRender->g, m_clrRender->b, 255, kRenderFxNone ); |
|
|
|
Vector vecVelocity( 0, 0, random->RandomFloat(40, 80) ); |
|
pSprite->SetAbsVelocity( vecVelocity ); |
|
pSprite->SetScale( m_spriteScale ); |
|
} |
|
if ( m_iszSpriteFlash != NULL_STRING ) |
|
{ |
|
CSprite *pSprite = CSprite::SpriteCreate( STRING(m_iszSpriteFlash), barrelEnd, TRUE ); |
|
pSprite->AnimateAndDie( 5 ); |
|
pSprite->SetTransparency( kRenderTransAdd, 255, 255, 255, 255, kRenderFxNoDissipation ); |
|
pSprite->SetScale( m_spriteScale ); |
|
} |
|
} |
|
|
|
if( pAttacker && pAttacker->IsPlayer() ) |
|
{ |
|
if ( IsX360() ) |
|
{ |
|
UTIL_PlayerByIndex(1)->RumbleEffect( RUMBLE_AR2, 0, RUMBLE_FLAG_RESTART | RUMBLE_FLAG_RANDOM_AMPLITUDE ); |
|
} |
|
else |
|
{ |
|
CSoundEnt::InsertSound( SOUND_MOVE_AWAY, barrelEnd + forward * 32.0f, 32.0f, 0.2f, pAttacker, SOUNDENT_CHANNEL_WEAPON ); |
|
} |
|
} |
|
|
|
|
|
m_OnFire.FireOutput(this, this); |
|
m_bReadyToFire = false; |
|
} |
|
|
|
|
|
void CFuncTank::TankTrace( const Vector &vecStart, const Vector &vecForward, const Vector &vecSpread, trace_t &tr ) |
|
{ |
|
Vector forward, right, up; |
|
|
|
AngleVectors( GetAbsAngles(), &forward, &right, &up ); |
|
// get circular gaussian spread |
|
float x, y, z; |
|
do { |
|
x = random->RandomFloat(-0.5,0.5) + random->RandomFloat(-0.5,0.5); |
|
y = random->RandomFloat(-0.5,0.5) + random->RandomFloat(-0.5,0.5); |
|
z = x*x+y*y; |
|
} while (z > 1); |
|
Vector vecDir = vecForward + |
|
x * vecSpread.x * right + |
|
y * vecSpread.y * up; |
|
Vector vecEnd; |
|
|
|
vecEnd = vecStart + vecDir * MAX_TRACE_LENGTH; |
|
UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr ); |
|
} |
|
|
|
|
|
void CFuncTank::StartRotSound( void ) |
|
{ |
|
if ( m_spawnflags & SF_TANK_SOUNDON ) |
|
return; |
|
m_spawnflags |= SF_TANK_SOUNDON; |
|
|
|
if ( m_soundLoopRotate != NULL_STRING ) |
|
{ |
|
CPASAttenuationFilter filter( this ); |
|
filter.MakeReliable(); |
|
|
|
EmitSound_t ep; |
|
ep.m_nChannel = CHAN_STATIC; |
|
ep.m_pSoundName = (char*)STRING(m_soundLoopRotate); |
|
ep.m_flVolume = 0.85; |
|
ep.m_SoundLevel = SNDLVL_NORM; |
|
|
|
EmitSound( filter, entindex(), ep ); |
|
} |
|
|
|
if ( m_soundStartRotate != NULL_STRING ) |
|
{ |
|
CPASAttenuationFilter filter( this ); |
|
|
|
EmitSound_t ep; |
|
ep.m_nChannel = CHAN_BODY; |
|
ep.m_pSoundName = (char*)STRING(m_soundStartRotate); |
|
ep.m_flVolume = 1.0f; |
|
ep.m_SoundLevel = SNDLVL_NORM; |
|
|
|
EmitSound( filter, entindex(), ep ); |
|
} |
|
} |
|
|
|
|
|
void CFuncTank::StopRotSound( void ) |
|
{ |
|
if ( m_spawnflags & SF_TANK_SOUNDON ) |
|
{ |
|
if ( m_soundLoopRotate != NULL_STRING ) |
|
{ |
|
StopSound( entindex(), CHAN_STATIC, (char*)STRING(m_soundLoopRotate) ); |
|
} |
|
if ( m_soundStopRotate != NULL_STRING ) |
|
{ |
|
CPASAttenuationFilter filter( this ); |
|
|
|
EmitSound_t ep; |
|
ep.m_nChannel = CHAN_BODY; |
|
ep.m_pSoundName = (char*)STRING(m_soundStopRotate); |
|
ep.m_flVolume = 1.0f; |
|
ep.m_SoundLevel = SNDLVL_NORM; |
|
|
|
EmitSound( filter, entindex(), ep ); |
|
} |
|
} |
|
m_spawnflags &= ~SF_TANK_SOUNDON; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CFuncTank::IsEntityInViewCone( CBaseEntity *pEntity ) |
|
{ |
|
// First check to see if the enemy is in range. |
|
Vector vecBarrelEnd = WorldBarrelPosition(); |
|
float flRange2 = ( pEntity->GetAbsOrigin() - vecBarrelEnd ).LengthSqr(); |
|
|
|
if( !(GetSpawnFlags() & SF_TANK_IGNORE_RANGE_IN_VIEWCONE) ) |
|
{ |
|
if ( !InRange2( flRange2 ) ) |
|
return false; |
|
} |
|
|
|
// If we're trying to shoot at a player, and we've seen a non-player recently, check the grace period |
|
if ( m_flPlayerGracePeriod && pEntity->IsPlayer() && (gpGlobals->curtime - m_flLastSawNonPlayer) < m_flPlayerGracePeriod ) |
|
{ |
|
// Grace period is ignored under a certain distance |
|
if ( flRange2 > m_flIgnoreGraceUpto ) |
|
return false; |
|
} |
|
|
|
// Check to see if the entity center lies within the yaw and pitch constraints. |
|
// This isn't horribly accurate, but should do for now. |
|
QAngle angGun; |
|
angGun = AimBarrelAt( m_parentMatrix.WorldToLocal( pEntity->GetAbsOrigin() ) ); |
|
|
|
// Force the angles to be relative to the center position |
|
float flOffsetY = UTIL_AngleDistance( angGun.y, m_yawCenter ); |
|
float flOffsetX = UTIL_AngleDistance( angGun.x, m_pitchCenter ); |
|
angGun.y = m_yawCenter + flOffsetY; |
|
angGun.x = m_pitchCenter + flOffsetX; |
|
|
|
if ( ( fabs( flOffsetY ) > m_yawRange + m_yawTolerance ) || ( fabs( flOffsetX ) > m_pitchRange + m_pitchTolerance ) ) |
|
return false; |
|
|
|
// Remember the last time we saw a non-player |
|
if ( !pEntity->IsPlayer() ) |
|
{ |
|
m_flLastSawNonPlayer = gpGlobals->curtime; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Return true if this func tank can see the enemy |
|
//----------------------------------------------------------------------------- |
|
bool CFuncTank::HasLOSTo( CBaseEntity *pEntity ) |
|
{ |
|
if ( !pEntity ) |
|
return false; |
|
|
|
// Get the barrel position |
|
Vector vecBarrelEnd = WorldBarrelPosition(); |
|
Vector vecTarget = pEntity->BodyTarget( GetAbsOrigin(), false ); |
|
trace_t tr; |
|
|
|
// Ignore the func_tank and any prop it's parented to |
|
CTraceFilterSkipTwoEntities traceFilter( this, GetParent(), COLLISION_GROUP_NONE ); |
|
|
|
// UNDONE: Should this hit BLOCKLOS brushes? |
|
AI_TraceLine( vecBarrelEnd, vecTarget, MASK_BLOCKLOS_AND_NPCS, &traceFilter, &tr ); |
|
|
|
CBaseEntity *pHitEntity = tr.m_pEnt; |
|
|
|
// Is entity in a vehicle? if so, verify vehicle is target and return if so (so npc shoots at vehicle) |
|
CBaseCombatCharacter *pCCEntity = pEntity->MyCombatCharacterPointer(); |
|
if ( pCCEntity != NULL && pCCEntity->IsInAVehicle() ) |
|
{ |
|
// Ok, player in vehicle, check if vehicle is target we're looking at, fire if it is |
|
// Also, check to see if the owner of the entity is the vehicle, in which case it's valid too. |
|
// This catches vehicles that use bone followers. |
|
CBaseEntity *pVehicle = pCCEntity->GetVehicle()->GetVehicleEnt(); |
|
if ( pHitEntity == pVehicle || ( pHitEntity != NULL && pHitEntity->GetOwnerEntity() == pVehicle ) ) |
|
return true; |
|
} |
|
|
|
return ( tr.fraction == 1.0 || tr.m_pEnt == pEntity ); |
|
} |
|
|
|
// ############################################################################# |
|
// CFuncTankGun |
|
// ############################################################################# |
|
class CFuncTankGun : public CFuncTank |
|
{ |
|
public: |
|
DECLARE_CLASS( CFuncTankGun, CFuncTank ); |
|
|
|
void Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ); |
|
}; |
|
LINK_ENTITY_TO_CLASS( func_tank, CFuncTankGun ); |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankGun::Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ) |
|
{ |
|
int i; |
|
|
|
FireBulletsInfo_t info; |
|
info.m_iShots = 1; |
|
info.m_vecSrc = barrelEnd; |
|
info.m_vecDirShooting = forward; |
|
if ( bIgnoreSpread ) |
|
{ |
|
info.m_vecSpread = gTankSpread[0]; |
|
} |
|
else |
|
{ |
|
info.m_vecSpread = gTankSpread[m_spread]; |
|
} |
|
|
|
info.m_flDistance = MAX_TRACE_LENGTH; |
|
info.m_iTracerFreq = 1; |
|
info.m_flDamage = m_iBulletDamage; |
|
info.m_iPlayerDamage = m_iBulletDamageVsPlayer; |
|
info.m_pAttacker = pAttacker; |
|
info.m_pAdditionalIgnoreEnt = GetParent(); |
|
|
|
#ifdef HL2_EPISODIC |
|
if ( m_iAmmoType != -1 ) |
|
{ |
|
for ( i = 0; i < bulletCount; i++ ) |
|
{ |
|
info.m_iAmmoType = m_iAmmoType; |
|
FireBullets( info ); |
|
} |
|
} |
|
#else |
|
for ( i = 0; i < bulletCount; i++ ) |
|
{ |
|
switch( m_bulletType ) |
|
{ |
|
case TANK_BULLET_SMALL: |
|
info.m_iAmmoType = m_iSmallAmmoType; |
|
FireBullets( info ); |
|
break; |
|
|
|
case TANK_BULLET_MEDIUM: |
|
info.m_iAmmoType = m_iMediumAmmoType; |
|
FireBullets( info ); |
|
break; |
|
|
|
case TANK_BULLET_LARGE: |
|
info.m_iAmmoType = m_iLargeAmmoType; |
|
FireBullets( info ); |
|
break; |
|
|
|
default: |
|
case TANK_BULLET_NONE: |
|
break; |
|
} |
|
} |
|
#endif // HL2_EPISODIC |
|
|
|
CFuncTank::Fire( bulletCount, barrelEnd, forward, pAttacker, bIgnoreSpread ); |
|
} |
|
|
|
// ############################################################################# |
|
// CFuncTankPulseLaser |
|
// ############################################################################# |
|
class CFuncTankPulseLaser : public CFuncTankGun |
|
{ |
|
public: |
|
DECLARE_CLASS( CFuncTankPulseLaser, CFuncTankGun ); |
|
DECLARE_DATADESC(); |
|
|
|
void Precache(); |
|
void Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ); |
|
|
|
float m_flPulseSpeed; |
|
float m_flPulseWidth; |
|
color32 m_flPulseColor; |
|
float m_flPulseLife; |
|
float m_flPulseLag; |
|
string_t m_sPulseFireSound; |
|
}; |
|
LINK_ENTITY_TO_CLASS( func_tankpulselaser, CFuncTankPulseLaser ); |
|
|
|
BEGIN_DATADESC( CFuncTankPulseLaser ) |
|
|
|
DEFINE_KEYFIELD( m_flPulseSpeed, FIELD_FLOAT, "PulseSpeed" ), |
|
DEFINE_KEYFIELD( m_flPulseWidth, FIELD_FLOAT, "PulseWidth" ), |
|
DEFINE_KEYFIELD( m_flPulseColor, FIELD_COLOR32, "PulseColor" ), |
|
DEFINE_KEYFIELD( m_flPulseLife, FIELD_FLOAT, "PulseLife" ), |
|
DEFINE_KEYFIELD( m_flPulseLag, FIELD_FLOAT, "PulseLag" ), |
|
DEFINE_KEYFIELD( m_sPulseFireSound, FIELD_SOUNDNAME, "PulseFireSound" ), |
|
|
|
END_DATADESC() |
|
|
|
//------------------------------------------------------------------------------ |
|
// Purpose : |
|
// Input : |
|
// Output : |
|
//------------------------------------------------------------------------------ |
|
void CFuncTankPulseLaser::Precache(void) |
|
{ |
|
UTIL_PrecacheOther( "grenade_beam" ); |
|
|
|
if ( m_sPulseFireSound != NULL_STRING ) |
|
{ |
|
PrecacheScriptSound( STRING(m_sPulseFireSound) ); |
|
} |
|
BaseClass::Precache(); |
|
} |
|
//------------------------------------------------------------------------------ |
|
// Purpose : |
|
// Input : |
|
// Output : |
|
//------------------------------------------------------------------------------ |
|
void CFuncTankPulseLaser::Fire( int bulletCount, const Vector &barrelEnd, const Vector &vecForward, CBaseEntity *pAttacker, bool bIgnoreSpread ) |
|
{ |
|
// -------------------------------------------------- |
|
// Get direction vectors for spread |
|
// -------------------------------------------------- |
|
Vector vecUp = Vector(0,0,1); |
|
Vector vecRight; |
|
CrossProduct ( vecForward, vecUp, vecRight ); |
|
CrossProduct ( vecForward, -vecRight, vecUp ); |
|
|
|
for ( int i = 0; i < bulletCount; i++ ) |
|
{ |
|
// get circular gaussian spread |
|
float x, y, z; |
|
do { |
|
x = random->RandomFloat(-0.5,0.5) + random->RandomFloat(-0.5,0.5); |
|
y = random->RandomFloat(-0.5,0.5) + random->RandomFloat(-0.5,0.5); |
|
z = x*x+y*y; |
|
} while (z > 1); |
|
|
|
Vector vecDir = vecForward + x * gTankSpread[m_spread].x * vecRight + y * gTankSpread[m_spread].y * vecUp; |
|
|
|
CGrenadeBeam *pPulse = CGrenadeBeam::Create( pAttacker, barrelEnd); |
|
pPulse->Format(m_flPulseColor, m_flPulseWidth); |
|
pPulse->Shoot(vecDir,m_flPulseSpeed,m_flPulseLife,m_flPulseLag,m_iBulletDamage); |
|
|
|
if ( m_sPulseFireSound != NULL_STRING ) |
|
{ |
|
CPASAttenuationFilter filter( this, 0.6f ); |
|
|
|
EmitSound_t ep; |
|
ep.m_nChannel = CHAN_WEAPON; |
|
ep.m_pSoundName = (char*)STRING(m_sPulseFireSound); |
|
ep.m_flVolume = 1.0f; |
|
ep.m_SoundLevel = SNDLVL_85dB; |
|
|
|
EmitSound( filter, entindex(), ep ); |
|
} |
|
|
|
} |
|
CFuncTank::Fire( bulletCount, barrelEnd, vecForward, pAttacker, bIgnoreSpread ); |
|
} |
|
|
|
// ############################################################################# |
|
// CFuncTankLaser |
|
// ############################################################################# |
|
class CFuncTankLaser : public CFuncTank |
|
{ |
|
DECLARE_CLASS( CFuncTankLaser, CFuncTank ); |
|
public: |
|
void Activate( void ); |
|
void Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ); |
|
void Think( void ); |
|
CEnvLaser *GetLaser( void ); |
|
|
|
DECLARE_DATADESC(); |
|
|
|
private: |
|
CEnvLaser *m_pLaser; |
|
float m_laserTime; |
|
string_t m_iszLaserName; |
|
}; |
|
LINK_ENTITY_TO_CLASS( func_tanklaser, CFuncTankLaser ); |
|
|
|
BEGIN_DATADESC( CFuncTankLaser ) |
|
|
|
DEFINE_KEYFIELD( m_iszLaserName, FIELD_STRING, "laserentity" ), |
|
|
|
DEFINE_FIELD( m_pLaser, FIELD_CLASSPTR ), |
|
DEFINE_FIELD( m_laserTime, FIELD_TIME ), |
|
|
|
END_DATADESC() |
|
|
|
|
|
void CFuncTankLaser::Activate( void ) |
|
{ |
|
BaseClass::Activate(); |
|
|
|
if ( !GetLaser() ) |
|
{ |
|
UTIL_Remove(this); |
|
Warning( "Laser tank with no env_laser!\n" ); |
|
} |
|
else |
|
{ |
|
m_pLaser->TurnOff(); |
|
} |
|
} |
|
|
|
|
|
CEnvLaser *CFuncTankLaser::GetLaser( void ) |
|
{ |
|
if ( m_pLaser ) |
|
return m_pLaser; |
|
|
|
CBaseEntity *pLaser = gEntList.FindEntityByName( NULL, m_iszLaserName ); |
|
while ( pLaser ) |
|
{ |
|
// Found the landmark |
|
if ( FClassnameIs( pLaser, "env_laser" ) ) |
|
{ |
|
m_pLaser = (CEnvLaser *)pLaser; |
|
break; |
|
} |
|
else |
|
{ |
|
pLaser = gEntList.FindEntityByName( pLaser, m_iszLaserName ); |
|
} |
|
} |
|
|
|
return m_pLaser; |
|
} |
|
|
|
|
|
void CFuncTankLaser::Think( void ) |
|
{ |
|
if ( m_pLaser && (gpGlobals->curtime > m_laserTime) ) |
|
m_pLaser->TurnOff(); |
|
|
|
CFuncTank::Think(); |
|
} |
|
|
|
|
|
void CFuncTankLaser::Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ) |
|
{ |
|
int i; |
|
trace_t tr; |
|
|
|
if ( GetLaser() ) |
|
{ |
|
for ( i = 0; i < bulletCount; i++ ) |
|
{ |
|
m_pLaser->SetLocalOrigin( barrelEnd ); |
|
TankTrace( barrelEnd, forward, gTankSpread[m_spread], tr ); |
|
|
|
m_laserTime = gpGlobals->curtime; |
|
m_pLaser->TurnOn(); |
|
m_pLaser->SetFireTime( gpGlobals->curtime - 1.0 ); |
|
m_pLaser->FireAtPoint( tr ); |
|
m_pLaser->SetNextThink( TICK_NEVER_THINK ); |
|
} |
|
CFuncTank::Fire( bulletCount, barrelEnd, forward, this, bIgnoreSpread ); |
|
} |
|
} |
|
|
|
class CFuncTankRocket : public CFuncTank |
|
{ |
|
public: |
|
DECLARE_CLASS( CFuncTankRocket, CFuncTank ); |
|
|
|
void Precache( void ); |
|
void Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ); |
|
virtual float GetShotSpeed() { return m_flRocketSpeed; } |
|
|
|
protected: |
|
float m_flRocketSpeed; |
|
|
|
DECLARE_DATADESC(); |
|
}; |
|
|
|
BEGIN_DATADESC( CFuncTankRocket ) |
|
|
|
DEFINE_KEYFIELD( m_flRocketSpeed, FIELD_FLOAT, "rocketspeed" ), |
|
|
|
END_DATADESC() |
|
|
|
LINK_ENTITY_TO_CLASS( func_tankrocket, CFuncTankRocket ); |
|
|
|
void CFuncTankRocket::Precache( void ) |
|
{ |
|
UTIL_PrecacheOther( "rpg_missile" ); |
|
CFuncTank::Precache(); |
|
} |
|
|
|
void CFuncTankRocket::Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ) |
|
{ |
|
CMissile *pRocket = (CMissile *) CBaseEntity::Create( "rpg_missile", barrelEnd, GetAbsAngles(), this ); |
|
|
|
pRocket->DumbFire(); |
|
pRocket->SetNextThink( gpGlobals->curtime + 0.1f ); |
|
pRocket->SetAbsVelocity( forward * m_flRocketSpeed ); |
|
if ( GetController() && GetController()->IsPlayer() ) |
|
{ |
|
pRocket->SetDamage( m_iBulletDamage ); |
|
} |
|
else |
|
{ |
|
pRocket->SetDamage( m_iBulletDamageVsPlayer ); |
|
} |
|
|
|
CFuncTank::Fire( bulletCount, barrelEnd, forward, this, bIgnoreSpread ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Airboat gun |
|
//----------------------------------------------------------------------------- |
|
class CFuncTankAirboatGun : public CFuncTank |
|
{ |
|
public: |
|
DECLARE_CLASS( CFuncTankAirboatGun, CFuncTank ); |
|
DECLARE_DATADESC(); |
|
|
|
void Precache( void ); |
|
virtual void Spawn(); |
|
virtual void Activate(); |
|
virtual void Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ); |
|
virtual void ControllerPostFrame(); |
|
virtual void OnStopControlled(); |
|
virtual const char *GetTracerType( void ); |
|
virtual Vector WorldBarrelPosition( void ); |
|
virtual void DoImpactEffect( trace_t &tr, int nDamageType ); |
|
|
|
private: |
|
void CreateSounds(); |
|
void DestroySounds(); |
|
void DoMuzzleFlash( ); |
|
void StartFiring(); |
|
void StopFiring(); |
|
|
|
CSoundPatch *m_pGunFiringSound; |
|
float m_flNextHeavyShotTime; |
|
bool m_bIsFiring; |
|
|
|
string_t m_iszAirboatGunModel; |
|
CHandle<CBaseAnimating> m_hAirboatGunModel; |
|
int m_nGunBarrelAttachment; |
|
float m_flLastImpactEffectTime; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Save/load: |
|
//----------------------------------------------------------------------------- |
|
BEGIN_DATADESC( CFuncTankAirboatGun ) |
|
|
|
DEFINE_SOUNDPATCH( m_pGunFiringSound ), |
|
DEFINE_FIELD( m_flNextHeavyShotTime, FIELD_TIME ), |
|
DEFINE_FIELD( m_bIsFiring, FIELD_BOOLEAN ), |
|
DEFINE_KEYFIELD( m_iszAirboatGunModel, FIELD_STRING, "airboat_gun_model" ), |
|
// DEFINE_FIELD( m_hAirboatGunModel, FIELD_EHANDLE ), |
|
// DEFINE_FIELD( m_nGunBarrelAttachment, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_flLastImpactEffectTime, FIELD_TIME ), |
|
|
|
END_DATADESC() |
|
|
|
LINK_ENTITY_TO_CLASS( func_tankairboatgun, CFuncTankAirboatGun ); |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Precache: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankAirboatGun::Precache( void ) |
|
{ |
|
BaseClass::Precache(); |
|
PrecacheScriptSound( "Airboat.FireGunLoop" ); |
|
PrecacheScriptSound( "Airboat.FireGunRevDown"); |
|
CreateSounds(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Precache: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankAirboatGun::Spawn( void ) |
|
{ |
|
BaseClass::Spawn(); |
|
m_flNextHeavyShotTime = 0.0f; |
|
m_bIsFiring = false; |
|
m_flLastImpactEffectTime = -1; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Attachment indices |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankAirboatGun::Activate() |
|
{ |
|
BaseClass::Activate(); |
|
|
|
if ( m_iszAirboatGunModel != NULL_STRING ) |
|
{ |
|
m_hAirboatGunModel = dynamic_cast<CBaseAnimating*>( gEntList.FindEntityByName( NULL, m_iszAirboatGunModel ) ); |
|
if ( m_hAirboatGunModel ) |
|
{ |
|
m_nGunBarrelAttachment = m_hAirboatGunModel->LookupAttachment( "muzzle" ); |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Create/destroy looping sounds |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankAirboatGun::CreateSounds() |
|
{ |
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController(); |
|
|
|
CPASAttenuationFilter filter( this ); |
|
if (!m_pGunFiringSound) |
|
{ |
|
m_pGunFiringSound = controller.SoundCreate( filter, entindex(), "Airboat.FireGunLoop" ); |
|
controller.Play( m_pGunFiringSound, 0, 100 ); |
|
} |
|
} |
|
|
|
void CFuncTankAirboatGun::DestroySounds() |
|
{ |
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController(); |
|
|
|
controller.SoundDestroy( m_pGunFiringSound ); |
|
m_pGunFiringSound = NULL; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Stop Firing |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankAirboatGun::StartFiring() |
|
{ |
|
if ( !m_bIsFiring ) |
|
{ |
|
CSoundEnvelopeController *pController = &CSoundEnvelopeController::GetController(); |
|
float flVolume = pController->SoundGetVolume( m_pGunFiringSound ); |
|
pController->SoundChangeVolume( m_pGunFiringSound, 1.0f, 0.1f * (1.0f - flVolume) ); |
|
m_bIsFiring = true; |
|
} |
|
} |
|
|
|
void CFuncTankAirboatGun::StopFiring() |
|
{ |
|
if ( m_bIsFiring ) |
|
{ |
|
CSoundEnvelopeController *pController = &CSoundEnvelopeController::GetController(); |
|
float flVolume = pController->SoundGetVolume( m_pGunFiringSound ); |
|
pController->SoundChangeVolume( m_pGunFiringSound, 0.0f, 0.1f * flVolume ); |
|
EmitSound( "Airboat.FireGunRevDown" ); |
|
m_bIsFiring = false; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Maintains airboat gun sounds |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankAirboatGun::ControllerPostFrame( void ) |
|
{ |
|
if ( IsPlayerManned() ) |
|
{ |
|
CBasePlayer *pPlayer = static_cast<CBasePlayer*>( GetController() ); |
|
if ( pPlayer->m_nButtons & IN_ATTACK ) |
|
{ |
|
StartFiring(); |
|
} |
|
else |
|
{ |
|
StopFiring(); |
|
} |
|
} |
|
|
|
BaseClass::ControllerPostFrame(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Stop controlled |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankAirboatGun::OnStopControlled() |
|
{ |
|
StopFiring(); |
|
BaseClass::OnStopControlled(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Barrel position |
|
//----------------------------------------------------------------------------- |
|
Vector CFuncTankAirboatGun::WorldBarrelPosition( void ) |
|
{ |
|
if ( !m_hAirboatGunModel || (m_nGunBarrelAttachment == 0) ) |
|
{ |
|
return BaseClass::WorldBarrelPosition(); |
|
} |
|
|
|
Vector vecOrigin; |
|
m_hAirboatGunModel->GetAttachment( m_nGunBarrelAttachment, vecOrigin ); |
|
return vecOrigin; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
const char *CFuncTankAirboatGun::GetTracerType( void ) |
|
{ |
|
if ( gpGlobals->curtime >= m_flNextHeavyShotTime ) |
|
return "AirboatGunHeavyTracer"; |
|
|
|
return "AirboatGunTracer"; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankAirboatGun::DoMuzzleFlash( void ) |
|
{ |
|
if ( m_hAirboatGunModel && (m_nGunBarrelAttachment != 0) ) |
|
{ |
|
CEffectData data; |
|
data.m_nEntIndex = m_hAirboatGunModel->entindex(); |
|
data.m_nAttachmentIndex = m_nGunBarrelAttachment; |
|
data.m_flScale = 1.0f; |
|
DispatchEffect( "AirboatMuzzleFlash", data ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Allows the shooter to change the impact effect of his bullets |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankAirboatGun::DoImpactEffect( trace_t &tr, int nDamageType ) |
|
{ |
|
// The airboat spits out so much crap that we need to do cheaper versions |
|
// of the impact effects. Also, we need to do less of them. |
|
if ( m_flLastImpactEffectTime == gpGlobals->curtime ) |
|
return; |
|
|
|
m_flLastImpactEffectTime = gpGlobals->curtime; |
|
UTIL_ImpactTrace( &tr, nDamageType, "AirboatGunImpact" ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Fires bullets |
|
//----------------------------------------------------------------------------- |
|
#define AIRBOAT_GUN_HEAVY_SHOT_INTERVAL 0.2f |
|
|
|
void CFuncTankAirboatGun::Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ) |
|
{ |
|
CAmmoDef *pAmmoDef = GetAmmoDef(); |
|
int ammoType = pAmmoDef->Index( "AirboatGun" ); |
|
|
|
FireBulletsInfo_t info; |
|
info.m_vecSrc = barrelEnd; |
|
info.m_vecDirShooting = forward; |
|
info.m_flDistance = 4096; |
|
info.m_iAmmoType = ammoType; |
|
|
|
if ( gpGlobals->curtime >= m_flNextHeavyShotTime ) |
|
{ |
|
info.m_iShots = 1; |
|
info.m_vecSpread = VECTOR_CONE_PRECALCULATED; |
|
info.m_flDamageForceScale = 1000.0f; |
|
} |
|
else |
|
{ |
|
info.m_iShots = 2; |
|
info.m_vecSpread = VECTOR_CONE_5DEGREES; |
|
} |
|
|
|
FireBullets( info ); |
|
|
|
DoMuzzleFlash(); |
|
|
|
// NOTE: This must occur after FireBullets |
|
if ( gpGlobals->curtime >= m_flNextHeavyShotTime ) |
|
{ |
|
m_flNextHeavyShotTime = gpGlobals->curtime + AIRBOAT_GUN_HEAVY_SHOT_INTERVAL; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// APC Rocket |
|
//----------------------------------------------------------------------------- |
|
#define DEATH_VOLLEY_MISSILE_COUNT 10 |
|
#define DEATH_VOLLEY_MIN_FIRE_RATE 3 |
|
#define DEATH_VOLLEY_MAX_FIRE_RATE 6 |
|
|
|
class CFuncTankAPCRocket : public CFuncTank |
|
{ |
|
public: |
|
DECLARE_CLASS( CFuncTankAPCRocket, CFuncTank ); |
|
|
|
void Precache( void ); |
|
virtual void Spawn(); |
|
virtual void UpdateOnRemove(); |
|
void Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ); |
|
virtual void Think(); |
|
virtual float GetShotSpeed() { return m_flRocketSpeed; } |
|
|
|
protected: |
|
void InputDeathVolley( inputdata_t &inputdata ); |
|
void FireDying( const Vector &barrelEnd ); |
|
|
|
EHANDLE m_hLaserDot; |
|
float m_flRocketSpeed; |
|
int m_nSide; |
|
int m_nBurstCount; |
|
bool m_bDying; |
|
|
|
DECLARE_DATADESC(); |
|
}; |
|
|
|
|
|
BEGIN_DATADESC( CFuncTankAPCRocket ) |
|
|
|
DEFINE_KEYFIELD( m_flRocketSpeed, FIELD_FLOAT, "rocketspeed" ), |
|
DEFINE_FIELD( m_hLaserDot, FIELD_EHANDLE ), |
|
DEFINE_FIELD( m_nSide, FIELD_INTEGER ), |
|
DEFINE_KEYFIELD( m_nBurstCount, FIELD_INTEGER, "burstcount" ), |
|
DEFINE_FIELD( m_bDying, FIELD_BOOLEAN ), |
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "DeathVolley", InputDeathVolley ), |
|
|
|
END_DATADESC() |
|
|
|
LINK_ENTITY_TO_CLASS( func_tankapcrocket, CFuncTankAPCRocket ); |
|
|
|
void CFuncTankAPCRocket::Precache( void ) |
|
{ |
|
UTIL_PrecacheOther( "apc_missile" ); |
|
|
|
PrecacheScriptSound( "PropAPC.FireCannon" ); |
|
|
|
CFuncTank::Precache(); |
|
} |
|
|
|
void CFuncTankAPCRocket::Spawn( void ) |
|
{ |
|
BaseClass::Spawn(); |
|
AddEffects( EF_NODRAW ); |
|
m_nSide = 0; |
|
m_bDying = false; |
|
m_hLaserDot = CreateLaserDot( GetAbsOrigin(), this, false ); |
|
m_nBulletCount = m_nBurstCount; |
|
SetSolid( SOLID_NONE ); |
|
SetLocalVelocity( vec3_origin ); |
|
} |
|
|
|
void CFuncTankAPCRocket::UpdateOnRemove( void ) |
|
{ |
|
if ( m_hLaserDot ) |
|
{ |
|
UTIL_Remove( m_hLaserDot ); |
|
m_hLaserDot = NULL; |
|
} |
|
BaseClass::UpdateOnRemove(); |
|
} |
|
|
|
void CFuncTankAPCRocket::FireDying( const Vector &barrelEnd ) |
|
{ |
|
Vector vecDir; |
|
vecDir.Random( -1.0f, 1.0f ); |
|
if ( vecDir.z < 0.0f ) |
|
{ |
|
vecDir.z *= -1.0f; |
|
} |
|
|
|
VectorNormalize( vecDir ); |
|
|
|
Vector vecVelocity; |
|
VectorMultiply( vecDir, m_flRocketSpeed * random->RandomFloat( 0.75f, 1.25f ), vecVelocity ); |
|
|
|
QAngle angles; |
|
VectorAngles( vecDir, angles ); |
|
|
|
CAPCMissile *pRocket = (CAPCMissile *) CAPCMissile::Create( barrelEnd, angles, vecVelocity, this ); |
|
float flDeathTime = random->RandomFloat( 0.3f, 0.5f ); |
|
if ( random->RandomFloat( 0.0f, 1.0f ) < 0.3f ) |
|
{ |
|
pRocket->ExplodeDelay( flDeathTime ); |
|
} |
|
else |
|
{ |
|
pRocket->AugerDelay( flDeathTime ); |
|
} |
|
|
|
// Make erratic firing |
|
m_fireRate = random->RandomFloat( DEATH_VOLLEY_MIN_FIRE_RATE, DEATH_VOLLEY_MAX_FIRE_RATE ); |
|
if ( --m_nBulletCount <= 0 ) |
|
{ |
|
UTIL_Remove( this ); |
|
} |
|
} |
|
|
|
void CFuncTankAPCRocket::Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ) |
|
{ |
|
static float s_pSide[] = { 0.966, 0.866, 0.5, -0.5, -0.866, -0.966 }; |
|
|
|
Vector vecDir; |
|
CrossProduct( Vector( 0, 0, 1 ), forward, vecDir ); |
|
vecDir.z = 1.0f; |
|
vecDir.x *= s_pSide[m_nSide]; |
|
vecDir.y *= s_pSide[m_nSide]; |
|
if ( ++m_nSide >= 6 ) |
|
{ |
|
m_nSide = 0; |
|
} |
|
|
|
VectorNormalize( vecDir ); |
|
|
|
Vector vecVelocity; |
|
VectorMultiply( vecDir, m_flRocketSpeed, vecVelocity ); |
|
|
|
QAngle angles; |
|
VectorAngles( vecDir, angles ); |
|
|
|
CAPCMissile *pRocket = (CAPCMissile *) CAPCMissile::Create( barrelEnd, angles, vecVelocity, this ); |
|
pRocket->IgniteDelay(); |
|
|
|
CFuncTank::Fire( bulletCount, barrelEnd, forward, this, bIgnoreSpread ); |
|
|
|
if ( --m_nBulletCount <= 0 ) |
|
{ |
|
m_nBulletCount = m_nBurstCount; |
|
|
|
// This will cause it to wait for a little while before shooting |
|
m_fireLast += random->RandomFloat( 2.0f, 3.0f ); |
|
} |
|
EmitSound( "PropAPC.FireCannon" ); |
|
} |
|
|
|
void CFuncTankAPCRocket::Think() |
|
{ |
|
// Inert if we're carried... |
|
if ( GetMoveParent() && GetMoveParent()->GetMoveParent() ) |
|
{ |
|
SetNextThink( gpGlobals->curtime + 0.5f ); |
|
return; |
|
} |
|
|
|
BaseClass::Think(); |
|
m_hLaserDot->SetAbsOrigin( m_sightOrigin ); |
|
SetLaserDotTarget( m_hLaserDot, m_hFuncTankTarget ); |
|
EnableLaserDot( m_hLaserDot, m_hFuncTankTarget != NULL ); |
|
|
|
if ( m_bDying ) |
|
{ |
|
FireDying( WorldBarrelPosition() ); |
|
return; |
|
} |
|
} |
|
|
|
|
|
void CFuncTankAPCRocket::InputDeathVolley( inputdata_t &inputdata ) |
|
{ |
|
if ( !m_bDying ) |
|
{ |
|
m_fireRate = random->RandomFloat( DEATH_VOLLEY_MIN_FIRE_RATE, DEATH_VOLLEY_MAX_FIRE_RATE ); |
|
SetNextAttack( gpGlobals->curtime + (1.0f / m_fireRate ) ); |
|
m_nBulletCount = DEATH_VOLLEY_MISSILE_COUNT; |
|
m_bDying = true; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Mortar shell |
|
//----------------------------------------------------------------------------- |
|
class CMortarShell : public CBaseEntity |
|
{ |
|
public: |
|
DECLARE_CLASS( CMortarShell, CBaseEntity ); |
|
|
|
static CMortarShell *Create( const Vector &vecStart, const Vector &vecTarget, const Vector &vecShotDir, float flImpactDelay, float flWarnDelay, string_t warnSound ); |
|
|
|
void Spawn( void ); |
|
void Precache( void ); |
|
void Impact( void ); |
|
void Warn( void ); |
|
void FlyThink( void ); |
|
void FadeThink( void ); |
|
int UpdateTransmitState( void ); |
|
|
|
private: |
|
|
|
void FixUpImpactPoint( const Vector &initialPos, const Vector &initialNormal, Vector *endPos, Vector *endNormal ); |
|
|
|
float m_flFadeTime; |
|
float m_flImpactTime; |
|
float m_flWarnTime; |
|
float m_flNPCWarnTime; |
|
string_t m_warnSound; |
|
int m_iSpriteTexture; |
|
bool m_bHasWarned; |
|
Vector m_vecFiredFrom; |
|
Vector m_vecFlyDir; |
|
float m_flSpawnedTime; |
|
|
|
CHandle<CBeam> m_pBeamEffect[4]; |
|
|
|
CNetworkVar( float, m_flLifespan ); |
|
CNetworkVar( float, m_flRadius ); |
|
CNetworkVar( Vector, m_vecSurfaceNormal ); |
|
|
|
DECLARE_DATADESC(); |
|
DECLARE_SERVERCLASS(); |
|
}; |
|
|
|
LINK_ENTITY_TO_CLASS( mortarshell, CMortarShell ); |
|
|
|
BEGIN_DATADESC( CMortarShell ) |
|
DEFINE_FIELD( m_flImpactTime, FIELD_TIME ), |
|
DEFINE_FIELD( m_flFadeTime, FIELD_TIME ), |
|
DEFINE_FIELD( m_flWarnTime, FIELD_TIME ), |
|
DEFINE_FIELD( m_flNPCWarnTime, FIELD_TIME ), |
|
DEFINE_FIELD( m_warnSound, FIELD_STRING ), |
|
DEFINE_FIELD( m_iSpriteTexture, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_bHasWarned, FIELD_BOOLEAN ), |
|
DEFINE_FIELD( m_flLifespan, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_vecFiredFrom, FIELD_POSITION_VECTOR ), |
|
DEFINE_FIELD( m_vecFlyDir, FIELD_VECTOR ), |
|
DEFINE_FIELD( m_flSpawnedTime, FIELD_TIME ), |
|
DEFINE_AUTO_ARRAY( m_pBeamEffect, FIELD_EHANDLE), |
|
DEFINE_FIELD( m_flRadius, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_vecSurfaceNormal, FIELD_VECTOR ), |
|
|
|
DEFINE_FUNCTION( FlyThink ), |
|
DEFINE_FUNCTION( FadeThink ), |
|
END_DATADESC() |
|
|
|
IMPLEMENT_SERVERCLASS_ST( CMortarShell, DT_MortarShell ) |
|
SendPropFloat( SENDINFO( m_flLifespan ), -1, SPROP_NOSCALE ), |
|
SendPropFloat( SENDINFO( m_flRadius ), -1, SPROP_NOSCALE ), |
|
SendPropVector( SENDINFO( m_vecSurfaceNormal ), 0, SPROP_NORMAL ), |
|
END_SEND_TABLE() |
|
|
|
#define MORTAR_TEST_RADIUS 16.0f |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : &initialPos - |
|
// *endPos - |
|
// *endNormal - |
|
//----------------------------------------------------------------------------- |
|
void CMortarShell::FixUpImpactPoint( const Vector &initialPos, const Vector &initialNormal, Vector *endPos, Vector *endNormal ) |
|
{ |
|
Vector vecStartOffset; |
|
|
|
vecStartOffset = initialPos + ( initialNormal * 1.0f ); |
|
|
|
trace_t tr; |
|
UTIL_TraceLine( vecStartOffset, vecStartOffset - Vector( 0, 0, 256 ), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr ); |
|
|
|
if ( tr.fraction < 1.0f ) |
|
{ |
|
if ( endPos ) |
|
{ |
|
*endPos = tr.endpos + ( initialNormal * 16.0f ); |
|
} |
|
|
|
if ( endNormal ) |
|
{ |
|
*endNormal = tr.plane.normal; |
|
} |
|
} |
|
else |
|
{ |
|
if ( endPos ) |
|
{ |
|
*endPos = initialPos; |
|
} |
|
|
|
if ( endNormal ) |
|
{ |
|
*endNormal = initialNormal; |
|
} |
|
} |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
#define MORTAR_BLAST_DAMAGE 50 |
|
#define MORTAR_BLAST_HEIGHT 7500 |
|
|
|
CMortarShell *CMortarShell::Create( const Vector &vecStart, const Vector &vecTarget, const Vector &vecShotDir, float flImpactDelay, float flWarnDelay, string_t warnSound ) |
|
{ |
|
CMortarShell *pShell = (CMortarShell *)CreateEntityByName("mortarshell" ); |
|
|
|
// Place the mortar shell at the target location so that it can make the sound and explode. |
|
trace_t tr; |
|
UTIL_TraceLine( vecTarget, vecTarget + ( vecShotDir * 128.0f ), MASK_SOLID_BRUSHONLY, pShell, COLLISION_GROUP_NONE, &tr ); |
|
|
|
Vector targetPos, targetNormal; |
|
pShell->FixUpImpactPoint( tr.endpos, tr.plane.normal, &targetPos, &targetNormal ); |
|
|
|
UTIL_SetOrigin( pShell, targetPos ); |
|
|
|
Vector vecStartSkew, vecEndSkew; |
|
|
|
vecStartSkew = targetPos - vecStart; |
|
vecStartSkew[2] = 0.0f; |
|
float skewLength = VectorNormalize( vecStartSkew ); |
|
|
|
vecEndSkew = -vecStartSkew * ( skewLength * 0.25f ); |
|
vecStartSkew *= skewLength * 0.1f; |
|
|
|
// Muzzleflash beam |
|
pShell->m_pBeamEffect[0] = CBeam::BeamCreate( "sprites/laserbeam.vmt", 1 ); |
|
pShell->m_pBeamEffect[0]->PointsInit( vecStart, vecStart + Vector( vecStartSkew[0], vecStartSkew[1], MORTAR_BLAST_HEIGHT ) ); |
|
pShell->m_pBeamEffect[0]->SetColor( 16, 16, 8 ); |
|
pShell->m_pBeamEffect[0]->SetBrightness( 0 ); |
|
pShell->m_pBeamEffect[0]->SetNoise( 0 ); |
|
pShell->m_pBeamEffect[0]->SetBeamFlag( FBEAM_SHADEOUT ); |
|
pShell->m_pBeamEffect[0]->SetWidth( 64.0f ); |
|
pShell->m_pBeamEffect[0]->SetEndWidth( 64.0f ); |
|
|
|
pShell->m_pBeamEffect[1] = CBeam::BeamCreate( "sprites/laserbeam.vmt", 1 ); |
|
pShell->m_pBeamEffect[1]->PointsInit( vecStart, vecStart + Vector( vecStartSkew[0], vecStartSkew[1], MORTAR_BLAST_HEIGHT ) ); |
|
pShell->m_pBeamEffect[1]->SetColor( 255, 255, 255 ); |
|
pShell->m_pBeamEffect[1]->SetBrightness( 0 ); |
|
pShell->m_pBeamEffect[1]->SetNoise( 0 ); |
|
pShell->m_pBeamEffect[1]->SetBeamFlag( FBEAM_SHADEOUT ); |
|
pShell->m_pBeamEffect[1]->SetWidth( 8.0f ); |
|
pShell->m_pBeamEffect[1]->SetEndWidth( 8.0f ); |
|
|
|
trace_t skyTrace; |
|
UTIL_TraceLine( targetPos, targetPos + Vector( vecEndSkew[0], vecEndSkew[1], MORTAR_BLAST_HEIGHT ), MASK_SOLID_BRUSHONLY, pShell, COLLISION_GROUP_NONE, &skyTrace ); |
|
|
|
// We must touch the sky to make this beam |
|
if ( skyTrace.fraction <= 1.0f && skyTrace.surface.flags & SURF_SKY ) |
|
{ |
|
// Impact point beam |
|
pShell->m_pBeamEffect[2] = CBeam::BeamCreate( "sprites/laserbeam.vmt", 1 ); |
|
pShell->m_pBeamEffect[2]->PointsInit( targetPos, targetPos + Vector( vecEndSkew[0], vecEndSkew[1], MORTAR_BLAST_HEIGHT ) ); |
|
pShell->m_pBeamEffect[2]->SetColor( 16, 16, 8 ); |
|
pShell->m_pBeamEffect[2]->SetBrightness( 0 ); |
|
pShell->m_pBeamEffect[2]->SetNoise( 0 ); |
|
pShell->m_pBeamEffect[2]->SetBeamFlag( FBEAM_SHADEOUT ); |
|
pShell->m_pBeamEffect[2]->SetWidth( 32.0f ); |
|
pShell->m_pBeamEffect[2]->SetEndWidth( 32.0f ); |
|
|
|
pShell->m_pBeamEffect[3] = CBeam::BeamCreate( "sprites/laserbeam.vmt", 1 ); |
|
pShell->m_pBeamEffect[3]->PointsInit( targetPos, targetPos + Vector( vecEndSkew[0], vecEndSkew[1], MORTAR_BLAST_HEIGHT ) ); |
|
pShell->m_pBeamEffect[3]->SetColor( 255, 255, 255 ); |
|
pShell->m_pBeamEffect[3]->SetBrightness( 0 ); |
|
pShell->m_pBeamEffect[3]->SetNoise( 0 ); |
|
pShell->m_pBeamEffect[3]->SetBeamFlag( FBEAM_SHADEOUT ); |
|
pShell->m_pBeamEffect[3]->SetWidth( 4.0f ); |
|
pShell->m_pBeamEffect[3]->SetEndWidth( 4.0f ); |
|
} |
|
else |
|
{ |
|
// Mark these as not being used |
|
pShell->m_pBeamEffect[2] = NULL; |
|
pShell->m_pBeamEffect[3] = NULL; |
|
} |
|
|
|
pShell->m_vecFiredFrom = vecStart; |
|
pShell->m_flLifespan = flImpactDelay; |
|
pShell->m_flImpactTime = gpGlobals->curtime + flImpactDelay; |
|
pShell->m_flWarnTime = pShell->m_flImpactTime - flWarnDelay; |
|
pShell->m_flNPCWarnTime = pShell->m_flWarnTime - 0.5; |
|
pShell->m_warnSound = warnSound; |
|
pShell->Spawn(); |
|
|
|
// Save off the impact normal |
|
pShell->m_vecSurfaceNormal = targetNormal; |
|
pShell->m_flRadius = MORTAR_BLAST_RADIUS; |
|
|
|
return pShell; |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CMortarShell::Precache() |
|
{ |
|
m_iSpriteTexture = PrecacheModel( "sprites/physbeam.vmt" ); |
|
|
|
PrecacheScriptSound( "Weapon_Mortar.Impact" ); |
|
PrecacheMaterial( "effects/ar2ground2" ); |
|
|
|
if ( NULL_STRING != m_warnSound ) |
|
{ |
|
PrecacheScriptSound( STRING( m_warnSound ) ); |
|
} |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// Purpose : Send even though we don't have a model |
|
//------------------------------------------------------------------------------ |
|
int CMortarShell::UpdateTransmitState( void ) |
|
{ |
|
return SetTransmitState( FL_EDICT_PVSCHECK ); |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CMortarShell::Spawn() |
|
{ |
|
Precache(); |
|
|
|
AddEffects( EF_NODRAW ); |
|
AddSolidFlags( FSOLID_NOT_SOLID ); |
|
|
|
Vector mins( -MORTAR_BLAST_RADIUS, -MORTAR_BLAST_RADIUS, -MORTAR_BLAST_RADIUS ); |
|
Vector maxs( MORTAR_BLAST_RADIUS, MORTAR_BLAST_RADIUS, MORTAR_BLAST_RADIUS ); |
|
|
|
UTIL_SetSize( this, mins, maxs ); |
|
|
|
m_vecFlyDir = GetAbsOrigin() - m_vecFiredFrom; |
|
VectorNormalize( m_vecFlyDir ); |
|
|
|
m_flSpawnedTime = gpGlobals->curtime; |
|
|
|
SetThink( &CMortarShell::FlyThink ); |
|
SetNextThink( gpGlobals->curtime ); |
|
|
|
// No model but we still need to force this! |
|
AddEFlags( EFL_FORCE_CHECK_TRANSMIT ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : type - |
|
// steps - |
|
// bias - |
|
//----------------------------------------------------------------------------- |
|
ConVar curve_bias( "curve_bias", "0.5" ); |
|
|
|
enum |
|
{ |
|
CURVE_BIAS, |
|
CURVE_GAIN, |
|
CURVE_SMOOTH, |
|
CURVE_SMOOTH_TWEAK, |
|
}; |
|
|
|
void UTIL_VisualizeCurve( int type, int steps, float bias ) |
|
{ |
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 ); |
|
Vector vForward, vRight, vUp; |
|
|
|
pPlayer->EyeVectors( &vForward, &vRight, &vUp ); |
|
|
|
Vector renderOrigin = pPlayer->EyePosition() + ( vForward * 512.0f ); |
|
|
|
float renderScale = 8.0f; |
|
float lastPerc, perc; |
|
|
|
Vector renderOffs, lastRenderOffs = vec3_origin; |
|
|
|
for ( int i = 0; i < steps; i++ ) |
|
{ |
|
perc = RemapValClamped( i, 0, steps-1, 0.0f, 1.0f ); |
|
|
|
switch( type ) |
|
{ |
|
case CURVE_BIAS: |
|
perc = Bias( perc, bias ); |
|
break; |
|
|
|
case CURVE_GAIN: |
|
perc = Gain( perc, bias ); |
|
break; |
|
|
|
case CURVE_SMOOTH: |
|
perc = SmoothCurve( perc ); |
|
break; |
|
|
|
case CURVE_SMOOTH_TWEAK: |
|
perc = SmoothCurve_Tweak( perc, bias, 0.9f ); |
|
break; |
|
} |
|
|
|
renderOffs = ( vRight * (-steps*0.5f) * renderScale ) + ( vUp * (renderScale*-(steps*0.5f)) )+ ( vRight * i * renderScale ) + ( vUp * perc * (renderScale*steps) ); |
|
|
|
NDebugOverlay::Cross3D( renderOrigin + renderOffs, -Vector(2,2,2), Vector(2,2,2), 255, 0, 0, true, 0.05f ); |
|
|
|
if ( i > 0 ) |
|
{ |
|
NDebugOverlay::Line( renderOrigin + renderOffs, renderOrigin + lastRenderOffs, 255, 0, 0, true, 0.05f ); |
|
} |
|
|
|
lastRenderOffs = renderOffs; |
|
lastPerc = perc; |
|
} |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CMortarShell::FlyThink() |
|
{ |
|
SetNextThink( gpGlobals->curtime + 0.05 ); |
|
|
|
if ( gpGlobals->curtime > m_flNPCWarnTime ) |
|
{ |
|
// Warn the AI. Make this radius a little larger than the explosion will be, and make the sound last a little longer. |
|
CSoundEnt::InsertSound ( SOUND_DANGER | SOUND_CONTEXT_MORTAR, GetAbsOrigin(), MORTAR_BLAST_RADIUS * 1.25, (m_flImpactTime - m_flNPCWarnTime) + 0.15 ); |
|
m_flNPCWarnTime = FLT_MAX; |
|
} |
|
|
|
//UTIL_VisualizeCurve( CURVE_GAIN, 64, curve_bias.GetFloat() ); |
|
|
|
float lifePerc = 1.0f - ( ( m_flImpactTime - gpGlobals->curtime ) / ( m_flImpactTime - m_flSpawnedTime ) ); |
|
|
|
lifePerc = clamp( lifePerc, 0.0f, 1.0f ); |
|
|
|
float curve1 = Bias( lifePerc, 0.75f ); |
|
|
|
// Beam updates START |
|
|
|
m_pBeamEffect[0]->SetBrightness( 255 * curve1 ); |
|
m_pBeamEffect[0]->SetWidth( 64.0f * curve1 ); |
|
m_pBeamEffect[0]->SetEndWidth( 64.0f * curve1 ); |
|
|
|
m_pBeamEffect[1]->SetBrightness( 255 * curve1 ); |
|
m_pBeamEffect[1]->SetWidth( 8.0f * curve1 ); |
|
m_pBeamEffect[1]->SetEndWidth( 8.0f * curve1 ); |
|
|
|
float curve2 = Bias( lifePerc, 0.1f ); |
|
|
|
if ( m_pBeamEffect[2] ) |
|
{ |
|
m_pBeamEffect[2]->SetBrightness( 255 * curve2 ); |
|
m_pBeamEffect[2]->SetWidth( 32.0f * curve2 ); |
|
m_pBeamEffect[2]->SetEndWidth( 32.0f * curve2 ); |
|
} |
|
|
|
if ( m_pBeamEffect[3] ) |
|
{ |
|
m_pBeamEffect[3]->SetBrightness( 255 * curve2 ); |
|
m_pBeamEffect[3]->SetWidth( 8.0f * curve2 ); |
|
m_pBeamEffect[3]->SetEndWidth( 8.0f * curve2 ); |
|
} |
|
|
|
// Beam updates END |
|
|
|
if( !m_bHasWarned && gpGlobals->curtime > m_flWarnTime ) |
|
{ |
|
Warn(); |
|
} |
|
|
|
if( gpGlobals->curtime > m_flImpactTime ) |
|
{ |
|
Impact(); |
|
} |
|
|
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CMortarShell::Warn( void ) |
|
{ |
|
if ( m_warnSound != NULL_STRING ) |
|
{ |
|
CPASAttenuationFilter filter( this ); |
|
|
|
EmitSound_t ep; |
|
ep.m_nChannel = CHAN_WEAPON; |
|
ep.m_pSoundName = (char*)STRING(m_warnSound); |
|
ep.m_flVolume = 1.0f; |
|
ep.m_SoundLevel = SNDLVL_NONE; |
|
|
|
EmitSound( filter, entindex(), ep ); |
|
} |
|
|
|
m_bHasWarned = true; |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CMortarShell::Impact( void ) |
|
{ |
|
// Fire the bullets |
|
Vector vecSrc, vecShootDir; |
|
|
|
float flRadius = MORTAR_BLAST_RADIUS; |
|
|
|
trace_t tr; |
|
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 128 ), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr ); |
|
|
|
UTIL_DecalTrace( &tr, "Scorch" ); |
|
|
|
// Send the effect over |
|
CEffectData data; |
|
|
|
// Do an extra effect if we struck the world |
|
if ( tr.m_pEnt && tr.m_pEnt->IsWorld() ) |
|
{ |
|
data.m_flRadius = flRadius * 0.5f; |
|
data.m_vNormal = tr.plane.normal; |
|
data.m_vOrigin = tr.endpos; |
|
|
|
DispatchEffect( "AR2Explosion", data ); |
|
} |
|
|
|
//Shockring |
|
CBroadcastRecipientFilter filter2; |
|
te->BeamRingPoint( filter2, 0, GetAbsOrigin(), //origin |
|
8.0f, //start radius |
|
flRadius * 2, //end radius |
|
m_iSpriteTexture, //texture |
|
0, //halo index |
|
0, //start frame |
|
2, //framerate |
|
0.2f, //life |
|
32, //width |
|
0, //spread |
|
0, //amplitude |
|
255, //r |
|
255, //g |
|
225, //b |
|
32, //a |
|
0, //speed |
|
FBEAM_FADEOUT |
|
); |
|
|
|
//Shockring |
|
te->BeamRingPoint( filter2, 0, GetAbsOrigin(), //origin |
|
8.0f, //start radius |
|
flRadius, //end radius |
|
m_iSpriteTexture, //texture |
|
0, //halo index |
|
0, //start frame |
|
2, //framerate |
|
0.2f, //life |
|
64, //width |
|
0, //spread |
|
0, //amplitude |
|
255, //r |
|
255, //g |
|
225, //b |
|
64, //a |
|
0, //speed |
|
FBEAM_FADEOUT |
|
); |
|
|
|
RadiusDamage( CTakeDamageInfo( this, GetOwnerEntity(), MORTAR_BLAST_DAMAGE, (DMG_BLAST|DMG_DISSOLVE) ), GetAbsOrigin(), MORTAR_BLAST_RADIUS, CLASS_NONE, NULL ); |
|
|
|
EmitSound( "Weapon_Mortar.Impact" ); |
|
|
|
UTIL_ScreenShake( GetAbsOrigin(), 10, 60, 1.0, 550, SHAKE_START, false ); |
|
|
|
//Fade the beams over time! |
|
m_flFadeTime = gpGlobals->curtime; |
|
|
|
SetThink( &CMortarShell::FadeThink ); |
|
SetNextThink( gpGlobals->curtime + 0.05f ); |
|
} |
|
|
|
#define MORTAR_FADE_LENGTH 1.0f |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CMortarShell::FadeThink( void ) |
|
{ |
|
SetNextThink( gpGlobals->curtime + 0.05f ); |
|
|
|
float lifePerc = 1.0f - ( ( gpGlobals->curtime - m_flFadeTime ) / MORTAR_FADE_LENGTH ); |
|
|
|
lifePerc = clamp( lifePerc, 0.0f, 1.0f ); |
|
|
|
float curve1 = Bias( lifePerc, 0.1f ); |
|
|
|
// Beam updates START |
|
|
|
m_pBeamEffect[0]->SetBrightness( 255 * curve1 ); |
|
m_pBeamEffect[0]->SetWidth( 64.0f * curve1 ); |
|
m_pBeamEffect[0]->SetEndWidth( 64.0f * curve1 ); |
|
|
|
m_pBeamEffect[1]->SetBrightness( 255 * curve1 ); |
|
m_pBeamEffect[1]->SetWidth( 8.0f * curve1 ); |
|
m_pBeamEffect[1]->SetEndWidth( 8.0f * curve1 ); |
|
|
|
float curve2 = Bias( lifePerc, 0.25f ); |
|
|
|
if ( m_pBeamEffect[2] ) |
|
{ |
|
m_pBeamEffect[2]->SetBrightness( 255 * curve2 ); |
|
m_pBeamEffect[2]->SetWidth( 32.0f * curve2 ); |
|
m_pBeamEffect[2]->SetEndWidth( 32.0f * curve2 ); |
|
} |
|
|
|
if ( m_pBeamEffect[3] ) |
|
{ |
|
m_pBeamEffect[3]->SetBrightness( 255 * curve2 ); |
|
m_pBeamEffect[3]->SetWidth( 8.0f * curve2 ); |
|
m_pBeamEffect[3]->SetEndWidth( 8.0f * curve2 ); |
|
} |
|
|
|
// Beam updates END |
|
|
|
if ( gpGlobals->curtime > ( m_flFadeTime + MORTAR_FADE_LENGTH ) ) |
|
{ |
|
UTIL_Remove( m_pBeamEffect[0] ); |
|
UTIL_Remove( m_pBeamEffect[1] ); |
|
UTIL_Remove( m_pBeamEffect[2] ); |
|
UTIL_Remove( m_pBeamEffect[3] ); |
|
|
|
SetThink(NULL); |
|
UTIL_Remove( this ); |
|
} |
|
} |
|
|
|
//========================================================= |
|
//========================================================= |
|
class CFuncTankMortar : public CFuncTank |
|
{ |
|
public: |
|
DECLARE_CLASS( CFuncTankMortar, CFuncTank ); |
|
|
|
CFuncTankMortar() { m_fLastShotMissed = false; } |
|
|
|
void Precache( void ); |
|
void FiringSequence( const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker ); |
|
void Fire( int bulletCount, const Vector &barrelEnd, const Vector &vecForward, CBaseEntity *pAttacker, bool bIgnoreSpread ); |
|
void ShootGun(void); |
|
void Spawn(); |
|
void SetNextAttack( float flWait ); |
|
|
|
// Input handlers. |
|
void InputShootGun( inputdata_t &inputdata ); |
|
void InputFireAtWill( inputdata_t &inputdata ); |
|
|
|
DECLARE_DATADESC(); |
|
|
|
int m_Magnitude; |
|
float m_fireDelay; |
|
string_t m_fireStartSound; |
|
//string_t m_fireEndSound; |
|
|
|
string_t m_incomingSound; |
|
float m_flWarningTime; |
|
float m_flFireVariance; |
|
|
|
bool m_fLastShotMissed; |
|
|
|
// store future firing event |
|
CBaseEntity *m_pAttacker; |
|
}; |
|
|
|
LINK_ENTITY_TO_CLASS( func_tankmortar, CFuncTankMortar ); |
|
|
|
BEGIN_DATADESC( CFuncTankMortar ) |
|
|
|
DEFINE_KEYFIELD( m_Magnitude, FIELD_INTEGER, "iMagnitude" ), |
|
DEFINE_KEYFIELD( m_fireDelay, FIELD_FLOAT, "firedelay" ), |
|
DEFINE_KEYFIELD( m_fireStartSound, FIELD_STRING, "firestartsound" ), |
|
//DEFINE_KEYFIELD( m_fireEndSound, FIELD_STRING, "fireendsound" ), |
|
DEFINE_KEYFIELD( m_incomingSound, FIELD_STRING, "incomingsound" ), |
|
DEFINE_KEYFIELD( m_flWarningTime, FIELD_TIME, "warningtime" ), |
|
DEFINE_KEYFIELD( m_flFireVariance, FIELD_TIME, "firevariance" ), |
|
|
|
DEFINE_FIELD( m_fLastShotMissed, FIELD_BOOLEAN ), |
|
|
|
DEFINE_FIELD( m_pAttacker, FIELD_CLASSPTR ), |
|
|
|
// Inputs |
|
DEFINE_INPUTFUNC( FIELD_VOID, "ShootGun", InputShootGun ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "FireAtWill", InputFireAtWill ), |
|
END_DATADESC() |
|
|
|
|
|
void CFuncTankMortar::Spawn() |
|
{ |
|
BaseClass::Spawn(); |
|
|
|
m_takedamage = DAMAGE_NO; |
|
} |
|
|
|
void CFuncTankMortar::Precache( void ) |
|
{ |
|
if ( m_fireStartSound != NULL_STRING ) |
|
PrecacheScriptSound( STRING(m_fireStartSound) ); |
|
//if ( m_fireEndSound != NULL_STRING ) |
|
// PrecacheScriptSound( STRING(m_fireEndSound) ); |
|
if ( m_incomingSound != NULL_STRING ) |
|
PrecacheScriptSound( STRING(m_incomingSound) ); |
|
BaseClass::Precache(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankMortar::SetNextAttack( float flWait ) |
|
{ |
|
if ( m_flFireVariance > 0.09 ) |
|
flWait += random->RandomFloat( -m_flFireVariance, m_flFireVariance ); |
|
BaseClass::SetNextAttack( flWait ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Input handler to make the tank shoot. |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankMortar::InputShootGun( inputdata_t &inputdata ) |
|
{ |
|
ShootGun(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// This mortar can fire the next round as soon as it is ready. This is not a |
|
// 'sticky' state, it just allows us to get the next shot off as soon as the |
|
// tank is on target. great for scripted applications where you need a shot as |
|
// soon as you can get it. |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankMortar::InputFireAtWill( inputdata_t &inputdata ) |
|
{ |
|
SetNextAttack( gpGlobals->curtime ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankMortar::ShootGun( void ) |
|
{ |
|
Vector forward; |
|
AngleVectors( GetLocalAngles(), &forward ); |
|
UpdateMatrix(); |
|
forward = m_parentMatrix.ApplyRotation( forward ); |
|
|
|
Fire( 1, WorldBarrelPosition(), forward, m_pAttacker, false ); |
|
} |
|
|
|
|
|
void CFuncTankMortar::FiringSequence( const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker ) |
|
{ |
|
if ( gpGlobals->curtime > GetNextAttack() ) |
|
{ |
|
ShootGun(); |
|
m_fireLast = gpGlobals->curtime; |
|
SetNextAttack( gpGlobals->curtime + (1.0 / m_fireRate ) ); |
|
} |
|
else |
|
{ |
|
m_fireLast = gpGlobals->curtime; |
|
} |
|
} |
|
|
|
void CFuncTankMortar::Fire( int bulletCount, const Vector &barrelEnd, const Vector &vecForward, CBaseEntity *pAttacker, bool bIgnoreSpread ) |
|
{ |
|
Vector vecProjectedPosition = vec3_invalid; |
|
trace_t tr; |
|
|
|
if ( m_hTarget ) |
|
{ |
|
float leadTime = (m_fireDelay * 1.1); |
|
|
|
if ( m_hTarget->IsNPC() ) // Give NPCs a little extra grace |
|
leadTime = 1.25; |
|
|
|
Vector vLead = m_hTarget->GetSmoothedVelocity() * leadTime; |
|
Vector vNoise; |
|
|
|
vecProjectedPosition = m_hTarget->WorldSpaceCenter() + vLead; |
|
vNoise.AsVector2D().Random( -6*12, 6*12); |
|
vNoise.z = 0; |
|
|
|
if( m_hTarget->Classify() != CLASS_BULLSEYE ) |
|
{ |
|
// Don't apply noise when attacking a bullseye. |
|
vecProjectedPosition += vNoise; |
|
} |
|
} |
|
else if ( IsPlayerManned() ) |
|
{ |
|
CalcPlayerCrosshairTarget( &vecProjectedPosition ); |
|
} |
|
else if ( IsNPCManned() ) |
|
{ |
|
CalcNPCEnemyTarget( &vecProjectedPosition ); |
|
//vecProjectedPosition += GetEnemy()->GetSmoothedVelocity() * (m_fireDelay * 1.1); |
|
} |
|
else |
|
return; |
|
|
|
#define TARGET_SEARCH_DEPTH 100 |
|
|
|
// find something interesting to shoot at near the projected position. |
|
Vector delta; |
|
|
|
// Make a really rough approximation of the last half of the mortar trajectory and trace it. |
|
// Do this so that mortars fired into windows land on rooftops, and that targets projected |
|
// inside buildings (or out of the world) clip to the world. (usually a building facade) |
|
|
|
// Find halfway between the mortar and the target. |
|
Vector vecSpot = ( vecProjectedPosition + GetAbsOrigin() ) * 0.5; |
|
vecSpot.z = GetAbsOrigin().z; |
|
|
|
// Trace up to find the fake 'apex' of the shell. The skybox or 1024 units, whichever comes first. |
|
UTIL_TraceLine( vecSpot, vecSpot + Vector(0, 0, 1024), MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr ); |
|
vecSpot = tr.endpos; |
|
|
|
//NDebugOverlay::Line( tr.startpos, tr.endpos, 0,255,0, false, 5 ); |
|
|
|
// Now trace from apex to target |
|
UTIL_TraceLine( vecSpot, vecProjectedPosition, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr ); |
|
|
|
if( mortar_visualize.GetBool() ) |
|
{ |
|
NDebugOverlay::Line( tr.startpos, tr.endpos, 255,0,0, false, 5 ); |
|
} |
|
|
|
if ( m_fireStartSound != NULL_STRING ) |
|
{ |
|
CPASAttenuationFilter filter( this ); |
|
|
|
EmitSound_t ep; |
|
ep.m_nChannel = CHAN_WEAPON; |
|
ep.m_pSoundName = (char*)STRING(m_fireStartSound); |
|
ep.m_flVolume = 1.0f; |
|
ep.m_SoundLevel = SNDLVL_NONE; |
|
|
|
EmitSound( filter, entindex(), ep ); |
|
} |
|
|
|
Vector vecFinalDir = tr.endpos - tr.startpos; |
|
VectorNormalize( vecFinalDir ); |
|
|
|
CMortarShell::Create( barrelEnd, tr.endpos, vecFinalDir, m_fireDelay, m_flWarningTime, m_incomingSound ); |
|
BaseClass::Fire( bulletCount, barrelEnd, vecForward, this, bIgnoreSpread ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Func tank that fires physics cannisters placed on it |
|
//----------------------------------------------------------------------------- |
|
class CFuncTankPhysCannister : public CFuncTank |
|
{ |
|
public: |
|
DECLARE_CLASS( CFuncTankPhysCannister, CFuncTank ); |
|
DECLARE_DATADESC(); |
|
|
|
void Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ); |
|
|
|
protected: |
|
string_t m_iszBarrelVolume; |
|
CHandle<CBaseTrigger> m_hBarrelVolume; |
|
}; |
|
|
|
LINK_ENTITY_TO_CLASS( func_tankphyscannister, CFuncTankPhysCannister ); |
|
|
|
BEGIN_DATADESC( CFuncTankPhysCannister ) |
|
|
|
DEFINE_KEYFIELD( m_iszBarrelVolume, FIELD_STRING, "barrel_volume" ), |
|
DEFINE_FIELD( m_hBarrelVolume, FIELD_EHANDLE ), |
|
|
|
END_DATADESC() |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CFuncTankPhysCannister::Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ) |
|
{ |
|
// Find our barrel volume |
|
if ( !m_hBarrelVolume ) |
|
{ |
|
if ( m_iszBarrelVolume != NULL_STRING ) |
|
{ |
|
m_hBarrelVolume = dynamic_cast<CBaseTrigger*>( gEntList.FindEntityByName( NULL, m_iszBarrelVolume ) ); |
|
} |
|
|
|
if ( !m_hBarrelVolume ) |
|
{ |
|
Msg("ERROR: Couldn't find barrel volume for func_tankphyscannister %s.\n", STRING(GetEntityName()) ); |
|
return; |
|
} |
|
} |
|
|
|
// Do we have a cannister in our barrel volume? |
|
CPhysicsCannister *pCannister = (CPhysicsCannister *)m_hBarrelVolume->GetTouchedEntityOfType( "physics_cannister" ); |
|
if ( !pCannister ) |
|
{ |
|
// Play a no-ammo sound |
|
return; |
|
} |
|
|
|
// Fire the cannister! |
|
pCannister->CannisterFire( pAttacker ); |
|
} |
|
|
|
//========================================================= |
|
//========================================================= |
|
static const char *s_pUpdateBeamThinkContext = "UpdateBeamThinkContext"; |
|
#define COMBINE_CANNON_BEAM "effects/blueblacklargebeam.vmt" |
|
//#define COMBINE_CANNON_BEAM "sprites/strider_bluebeam.vmt" |
|
|
|
class CFuncTankCombineCannon : public CFuncTankGun |
|
{ |
|
DECLARE_CLASS( CFuncTankCombineCannon, CFuncTankGun ); |
|
|
|
void Precache(); |
|
void Spawn(); |
|
void CreateBeam(); |
|
void DestroyBeam(); |
|
void FuncTankPostThink(); |
|
void AdjustRateOfFire(); |
|
void UpdateBeamThink( void ); |
|
void Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ); |
|
void MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType ); |
|
void TankDeactivate(); |
|
|
|
void InputSetTargetEntity( inputdata_t &inputdata ); |
|
void InputClearTargetEntity( inputdata_t &inputdata ); |
|
|
|
void InputEnableHarrass( inputdata_t &inputdata ); |
|
void InputDisableHarrass( inputdata_t &inputdata ); |
|
|
|
COutputEvent m_OnShotAtPlayer; |
|
|
|
CHandle<CBeam> m_hBeam; |
|
|
|
DECLARE_DATADESC(); |
|
|
|
private: |
|
float m_originalFireRate; |
|
float m_flTimeNextSweep; |
|
float m_flTimeBeamOn; |
|
Vector m_vecTrueForward; |
|
bool m_bShouldHarrass; |
|
bool m_bLastTargetWasNPC; // Tells whether the last entity we fired a shot at was an NPC (otherwise it was the player) |
|
}; |
|
|
|
BEGIN_DATADESC( CFuncTankCombineCannon ) |
|
DEFINE_FIELD( m_originalFireRate, FIELD_FLOAT ), |
|
DEFINE_THINKFUNC( UpdateBeamThink ), |
|
DEFINE_FIELD( m_flTimeNextSweep, FIELD_TIME ), |
|
DEFINE_FIELD( m_flTimeBeamOn, FIELD_TIME ), |
|
DEFINE_FIELD( m_hBeam, FIELD_EHANDLE ), |
|
DEFINE_FIELD( m_vecTrueForward, FIELD_VECTOR ), |
|
DEFINE_FIELD( m_bShouldHarrass, FIELD_BOOLEAN ), |
|
DEFINE_FIELD( m_bLastTargetWasNPC, FIELD_BOOLEAN ), |
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "EnableHarrass", InputEnableHarrass ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "DisableHarrass", InputDisableHarrass ), |
|
|
|
DEFINE_OUTPUT( m_OnShotAtPlayer, "OnShotAtPlayer" ), |
|
|
|
END_DATADESC() |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::Precache() |
|
{ |
|
m_originalFireRate = m_fireRate; |
|
|
|
PrecacheModel(COMBINE_CANNON_BEAM); |
|
PrecacheParticleSystem( "Weapon_Combine_Ion_Cannon" ); |
|
|
|
BaseClass::Precache(); |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::Spawn() |
|
{ |
|
BaseClass::Spawn(); |
|
m_flTimeBeamOn = gpGlobals->curtime; |
|
CreateBeam(); |
|
|
|
m_bShouldHarrass = true; |
|
|
|
GetVectors( &m_vecTrueForward, NULL, NULL ); |
|
m_bLastTargetWasNPC = false; |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::CreateBeam() |
|
{ |
|
if (!m_hBeam && gpGlobals->curtime >= m_flTimeBeamOn ) |
|
{ |
|
m_hBeam = CBeam::BeamCreate( COMBINE_CANNON_BEAM, 1.0f ); |
|
m_hBeam->SetColor( 255, 255, 255 ); |
|
SetContextThink( &CFuncTankCombineCannon::UpdateBeamThink, gpGlobals->curtime, s_pUpdateBeamThinkContext ); |
|
} |
|
else |
|
{ |
|
// Beam seems to be on, or I'm not supposed to have it on at the moment. |
|
return; |
|
} |
|
|
|
Vector vecInitialAim; |
|
|
|
AngleVectors( GetAbsAngles(), &vecInitialAim, NULL, NULL ); |
|
|
|
m_hBeam->PointsInit( WorldBarrelPosition(), WorldBarrelPosition() + vecInitialAim ); |
|
m_hBeam->SetBrightness( 255 ); |
|
m_hBeam->SetNoise( 0 ); |
|
m_hBeam->SetWidth( 3.0f ); |
|
m_hBeam->SetEndWidth( 0 ); |
|
m_hBeam->SetScrollRate( 0 ); |
|
m_hBeam->SetFadeLength( 60 ); // five feet to fade out |
|
//m_hBeam->SetHaloTexture( sHaloSprite ); |
|
m_hBeam->SetHaloScale( 4.0f ); |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::DestroyBeam() |
|
{ |
|
if( m_hBeam ) |
|
{ |
|
UTIL_Remove( m_hBeam ); |
|
m_hBeam.Set(NULL); |
|
} |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::AdjustRateOfFire() |
|
{ |
|
// Maintain 1.5 rounds per second rate of fire. |
|
m_fireRate = 1.5; |
|
/* |
|
if( m_hTarget.Get() != NULL && m_hTarget->IsPlayer() ) |
|
{ |
|
if( m_bLastTargetWasNPC ) |
|
{ |
|
// Cheat, and be able to fire RIGHT NOW if the target is a player and the |
|
// last target I fired at was an NPC. This prevents the player from running |
|
// for it while the gun is busy dealing with NPCs |
|
SetNextAttack( gpGlobals->curtime ); |
|
} |
|
} |
|
*/ |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
#define COMBINE_CANNON_BEAM_MAX_DIST 1900.0f |
|
void CFuncTankCombineCannon::UpdateBeamThink() |
|
{ |
|
SetContextThink( &CFuncTankCombineCannon::UpdateBeamThink, gpGlobals->curtime + 0.025, s_pUpdateBeamThinkContext ); |
|
|
|
// Always try to create the beam. |
|
CreateBeam(); |
|
|
|
if( !m_hBeam ) |
|
return; |
|
|
|
trace_t trBeam; |
|
trace_t trShot; |
|
trace_t trBlockLOS; |
|
|
|
Vector vecBarrel = WorldBarrelPosition(); |
|
Vector vecAim; |
|
AngleVectors( GetAbsAngles(), &vecAim, NULL, NULL ); |
|
|
|
AI_TraceLine( vecBarrel, vecBarrel + vecAim * COMBINE_CANNON_BEAM_MAX_DIST, MASK_SHOT, this, COLLISION_GROUP_NONE, &trBeam ); |
|
|
|
m_hBeam->SetStartPos( trBeam.startpos ); |
|
m_hBeam->SetEndPos( trBeam.endpos ); |
|
|
|
if( !(m_spawnflags & SF_TANK_AIM_AT_POS) ) |
|
{ |
|
SetTargetPosition( trBeam.endpos ); |
|
} |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::FuncTankPostThink() |
|
{ |
|
AdjustRateOfFire(); |
|
|
|
if( m_hTarget.Get() == NULL ) |
|
{ |
|
if( gpGlobals->curtime > m_flTimeNextSweep ) |
|
{ |
|
AddSpawnFlags( SF_TANK_AIM_AT_POS ); |
|
|
|
Vector vecTargetPosition = GetTargetPosition(); |
|
CBasePlayer *pPlayer = AI_GetSinglePlayer(); |
|
Vector vecToPlayer = pPlayer->WorldSpaceCenter() - GetAbsOrigin(); |
|
vecToPlayer.NormalizeInPlace(); |
|
|
|
bool bHarass = false; |
|
float flDot = DotProduct( m_vecTrueForward, vecToPlayer ); |
|
|
|
if( flDot >= 0.9f && m_bShouldHarrass ) |
|
{ |
|
//Msg("%s Harrassing player\n", GetDebugName() ); |
|
vecTargetPosition = pPlayer->EyePosition(); |
|
bHarass = true; |
|
} |
|
else |
|
{ |
|
//Msg( "%s Bored\n", GetDebugName() ); |
|
// Just point off in the distance, more or less directly ahead of me. |
|
vecTargetPosition = GetAbsOrigin() + m_vecTrueForward * 1900.0f; |
|
} |
|
|
|
int i; |
|
Vector vecTest; |
|
bool bFoundPoint = false; |
|
for( i = 0 ; i < 5 ; i++ ) |
|
{ |
|
vecTest = vecTargetPosition; |
|
|
|
if( bHarass ) |
|
{ |
|
vecTest.x += random->RandomFloat( -48, 48 ); |
|
vecTest.y += random->RandomFloat( -48, 48 ); |
|
vecTest.z += random->RandomFloat( 16, 48 ); |
|
} |
|
else |
|
{ |
|
vecTest.x += random->RandomFloat( -48, 48 ); |
|
vecTest.y += random->RandomFloat( -48, 48 ); |
|
vecTest.z += random->RandomFloat( -48, 48 ); |
|
} |
|
|
|
// Get the barrel position |
|
Vector vecBarrelEnd = WorldBarrelPosition(); |
|
trace_t trLOS; |
|
trace_t trShoot; |
|
|
|
// Ignore the func_tank and any prop it's parented to, and check line of sight to the point |
|
// Trace to the point. If an opaque trace doesn't reach the point, that means the beam hit |
|
// something closer, (including a blockLOS), so try again. |
|
CTraceFilterSkipTwoEntities traceFilter( this, GetParent(), COLLISION_GROUP_NONE ); |
|
AI_TraceLine( vecBarrelEnd, vecTest, MASK_BLOCKLOS_AND_NPCS, &traceFilter, &trLOS ); |
|
AI_TraceLine( vecBarrelEnd, vecTest, MASK_SHOT, &traceFilter, &trShoot ); |
|
|
|
if( trLOS.fraction < trShoot.fraction ) |
|
{ |
|
// Damn block LOS brushes. |
|
continue; |
|
} |
|
|
|
//Msg("Point is visible in %d tries\n", i); |
|
bFoundPoint = true; |
|
break; |
|
} |
|
|
|
if( bFoundPoint ) |
|
{ |
|
vecTargetPosition = vecTest; |
|
SetTargetPosition( vecTargetPosition ); |
|
//Msg("New place\n"); |
|
} |
|
|
|
if( bHarass ) |
|
{ |
|
m_flTimeNextSweep = gpGlobals->curtime + random->RandomFloat( 0.25f, 0.75f ); |
|
} |
|
else |
|
{ |
|
m_flTimeNextSweep = gpGlobals->curtime + random->RandomFloat( 1, 3 ); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
//Msg("%d engaging: %s\n", entindex(), m_hTarget->GetClassname() ); |
|
RemoveSpawnFlags( SF_TANK_AIM_AT_POS ); |
|
} |
|
} |
|
|
|
//--------------------------------------------------------- |
|
// A normal func_tank uses a method of aiming the gun that will |
|
// always follow a fast-moving player. This is because the func_tank |
|
// turns the weapon by applying angular velocities in the early |
|
// phase of the func_tank's Think(). Because the bullet is fired |
|
// later in the same think, it is fired before the game physics have |
|
// updated the func_tank's angles using the newly-computed angular |
|
// velocity, so the bullet always trails the target slightly. |
|
// This is unacceptable for the Combine Cannon, as the cannon MUST |
|
// strike a moving player with absolute certainty. As a quick |
|
// remedy, this code allows the combine cannon to fire a bullet |
|
// at a slightly different angle than the gun is aiming, to |
|
// ensure a hit. Large discrepancies are ignored and we accept |
|
// the miss instead of presenting a bullet fired at an obviously |
|
// adjusted angle. |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker, bool bIgnoreSpread ) |
|
{ |
|
// Specifically do NOT fire in aim at pos mode. This is just for show. |
|
if( HasSpawnFlags(SF_TANK_AIM_AT_POS) ) |
|
return; |
|
|
|
Vector vecAdjustedForward = forward; |
|
|
|
if( m_hTarget != NULL ) |
|
{ |
|
Vector vecToTarget = m_hTarget->BodyTarget( barrelEnd, false ) - barrelEnd; |
|
VectorNormalize( vecToTarget ); |
|
|
|
float flDot = DotProduct( vecToTarget, forward ); |
|
|
|
if( flDot >= 0.97 ) |
|
{ |
|
vecAdjustedForward = vecToTarget; |
|
} |
|
|
|
if( m_hTarget->IsNPC() ) |
|
m_bLastTargetWasNPC = true; |
|
else |
|
m_bLastTargetWasNPC = false; |
|
|
|
if( m_hTarget->IsPlayer() ) |
|
m_OnShotAtPlayer.FireOutput( this, this ); |
|
} |
|
|
|
BaseClass::Fire( bulletCount, barrelEnd, vecAdjustedForward, pAttacker, bIgnoreSpread ); |
|
|
|
// Turn off the beam and tell it to stay off for a bit. We want it to look like the beam became the |
|
// ion cannon 'rail gun' effect. |
|
DestroyBeam(); |
|
m_flTimeBeamOn = gpGlobals->curtime + 0.2f; |
|
|
|
m_flTimeNextSweep = gpGlobals->curtime + random->RandomInt( 1.0f, 2.0f ); |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType ) |
|
{ |
|
// If the shot passed near the player, shake the screen. |
|
if( AI_IsSinglePlayer() ) |
|
{ |
|
Vector vecPlayer = AI_GetSinglePlayer()->EyePosition(); |
|
|
|
Vector vecNearestPoint = PointOnLineNearestPoint( vecTracerSrc, tr.endpos, vecPlayer ); |
|
|
|
float flDist = vecPlayer.DistTo( vecNearestPoint ); |
|
|
|
if( flDist >= 10.0f && flDist <= 120.0f ) |
|
{ |
|
// Don't shake the screen if we're hit (within 10 inches), but do shake if a shot otherwise comes within 10 feet. |
|
UTIL_ScreenShake( vecNearestPoint, 10, 60, 0.3, 120.0f, SHAKE_START, false ); |
|
} |
|
} |
|
|
|
// Send the railgun effect |
|
DispatchParticleEffect( "Weapon_Combine_Ion_Cannon", vecTracerSrc, tr.endpos, vec3_angle, NULL ); |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::TankDeactivate() |
|
{ |
|
DestroyBeam(); |
|
m_flTimeBeamOn = gpGlobals->curtime + 1.0f; |
|
SetContextThink( NULL, 0, s_pUpdateBeamThinkContext ); |
|
|
|
BaseClass::TankDeactivate(); |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::InputSetTargetEntity( inputdata_t &inputdata ) |
|
{ |
|
BaseClass::InputSetTargetEntity( inputdata ); |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::InputClearTargetEntity( inputdata_t &inputdata ) |
|
{ |
|
/* |
|
m_targetEntityName = NULL_STRING; |
|
m_hTarget = NULL; |
|
|
|
// No longer aim at target position if have one |
|
m_spawnflags &= ~SF_TANK_AIM_AT_POS; |
|
*/ |
|
BaseClass::InputClearTargetEntity( inputdata ); |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::InputEnableHarrass( inputdata_t &inputdata ) |
|
{ |
|
m_bShouldHarrass = true; |
|
} |
|
|
|
//--------------------------------------------------------- |
|
//--------------------------------------------------------- |
|
void CFuncTankCombineCannon::InputDisableHarrass( inputdata_t &inputdata ) |
|
{ |
|
m_bShouldHarrass = false; |
|
} |
|
|
|
|
|
LINK_ENTITY_TO_CLASS( func_tank_combine_cannon, CFuncTankCombineCannon );
|
|
|