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.
4432 lines
126 KiB
4432 lines
126 KiB
5 years ago
|
//========= 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 );
|