//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ //=============================================================================// #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 "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" #if !defined( CSTRIKE15 ) #include "grenade_beam.h" #include "ai_behavior_functank.h" #include "weapon_rpg.h" #endif #include "effects.h" #include "iservervehicle.h" #include "soundenvelope.h" #include "effect_dispatch_data.h" #include "te_effect_dispatch.h" #include "props.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" 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" ), DEFINE_FIELD( m_iSmallAmmoType, FIELD_INTEGER ), DEFINE_FIELD( m_iMediumAmmoType, FIELD_INTEGER ), DEFINE_FIELD( m_iLargeAmmoType, FIELD_INTEGER ), 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 ) { #if !defined( CSTRIKE15 ) // 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(), NULL ); 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(); #endif } //----------------------------------------------------------------------------- // 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 ) { #if !defined( CSTRIKE15 ) // 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; #endif } //----------------------------------------------------------------------------- // 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 ) { #if !defined( CSTRIKE15 ) // 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 ); } #endif } //----------------------------------------------------------------------------- // 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)); } NDebugOverlay::EntityText(entindex(),text_offset,tempstr,0); text_offset++; // ------------------- // Print Firing Speed // -------------------- Q_snprintf(tempstr,sizeof(tempstr),"Fire Rate: %f",m_fireRate); NDebugOverlay::EntityText(entindex(),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: - "); } NDebugOverlay::EntityText(entindex(),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: - "); } NDebugOverlay::EntityText(entindex(),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(); m_iSmallAmmoType = GetAmmoDef()->Index("Pistol"); m_iMediumAmmoType = GetAmmoDef()->Index("SMG1"); m_iLargeAmmoType = GetAmmoDef()->Index("AR2"); SetMoveType( MOVETYPE_PUSH ); // so it doesn't get pushed by anything SetSolid( SOLID_VPHYSICS ); SetModel( STRING( GetModelName() ) ); 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(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" ); } 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( gEntList.FindEntityByName( NULL, m_iszControlVolume, NULL ) ); } 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( 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( 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 m_flNextControllerSearch = gpGlobals->curtime + 5.0f; SetNextThink( m_flNextControllerSearch ); } SetLocalAngularVelocity( vec3_angle ); } //----------------------------------------------------------------------------- // Purpose: // Called each frame by the player's ItemPostFrame //----------------------------------------------------------------------------- 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( 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 ); // 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, NULL ); 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; } } // Fire the bullet(s). Fire( 1, vecBarrelEnd, vecForward, m_hController ); --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 !defined( CSTRIKE15 ) 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 ); } #endif } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CFuncTank::NPC_InterruptController( void ) { #if !defined( CSTRIKE15 ) // 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(); } #endif 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( gEntList.FindEntityByName( NULL, m_iszControlVolume, NULL ) ); } 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 ) { 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(); } } // Keep thinking, in case they turn NPC finding back on if ( !HasController() ) { SetNextThink( gpGlobals->curtime + 2.0f ); } m_flNextControllerSearch = gpGlobals->curtime + 2.0f; } // refresh the matrix UpdateMatrix(); SetLocalAngularVelocity( vec3_angle ); TrackTarget(); if ( fabs(GetLocalAngularVelocity().x) > 1 || fabs(GetLocalAngularVelocity().y) > 1 ) { StartRotSound(); } else { StopRotSound(); } } //----------------------------------------------------------------------------- // 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( m_hController.Get() ); // Tank aims at player's crosshair. Vector vecStart, vecDir; trace_t tr; vecStart = pPlayer->EyePosition(); vecDir = pPlayer->EyeDirection3D(); // Make sure to start the trace outside of the player's bbox! UTIL_TraceLine( vecStart + vecDir * 24, vecStart + vecDir * 8192, MASK_OPAQUE_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(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 ); } } 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 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 ) { if ( m_iEffectHandling == EH_AR2 ) return "AR2Tracer"; 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 ) { // 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_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 ); } } 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 ); AI_TraceLine( vecBarrelEnd, vecTarget, MASK_OPAQUE_AND_NPCS, &traceFilter, &tr ); CBaseEntity *pHitEntity = tr.m_pEnt; CBasePlayer *pPlayer = ToBasePlayer( pEntity ); // Is player in a vehicle? if so, verify vehicle is target and return if so (so npc shoots at vehicle) if ( pPlayer && pPlayer->IsInAVehicle() && pHitEntity ) { // 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 = pPlayer->GetVehicle()->GetVehicleEnt(); if ( pHitEntity == pVehicle || 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 ); }; LINK_ENTITY_TO_CLASS( func_tank, CFuncTankGun ); //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CFuncTankGun::Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker ) { #if !defined( CSTRIKE15 ) int i; FireBulletsInfo_t info; info.m_iShots = 1; info.m_vecSrc = barrelEnd; info.m_vecDirShooting = forward; info.m_vecSpread = gTankSpread[m_spread]; info.m_flDistance = MAX_TRACE_LENGTH; info.m_iTracerFreq = 1; info.m_iDamage = m_iBulletDamage; info.m_iPlayerDamage = m_iBulletDamageVsPlayer; info.m_pAttacker = pAttacker; info.m_pAdditionalIgnoreEnt = GetParent(); 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; } } CFuncTank::Fire( bulletCount, barrelEnd, forward, pAttacker ); #endif } // ############################################################################# // 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 ); 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 ) { #if !defined( CSTRIKE15 ) // -------------------------------------------------- // 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 ); #endif } // ############################################################################# // 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 ); 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, NULL ); while ( pLaser ) { // Found the landmark if ( FClassnameIs( pLaser, "env_laser" ) ) { m_pLaser = (CEnvLaser *)pLaser; break; } else { pLaser = gEntList.FindEntityByName( pLaser, m_iszLaserName, NULL ); } } 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 ) { 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 ); } } class CFuncTankRocket : public CFuncTank { public: DECLARE_CLASS( CFuncTankRocket, CFuncTank ); void Precache( void ); void Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker ); 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 ) { #if !defined( CSTRIKE15 ) 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 ); #endif } //----------------------------------------------------------------------------- // 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 ); 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 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( gEntList.FindEntityByName( NULL, m_iszAirboatGunModel, NULL ) ); 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( 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; QAngle vecAngles; m_hAirboatGunModel->GetAttachment( m_nGunBarrelAttachment, vecOrigin, vecAngles ); 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 ) { 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 ); 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; #if !defined( CSTRIKE15 ) m_hLaserDot = CreateLaserDot( GetAbsOrigin(), this, false ); #endif 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 ) { #if !defined( CSTRIKE15 ) 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 ); } #endif } void CFuncTankAPCRocket::Fire( int bulletCount, const Vector &barrelEnd, const Vector &forward, CBaseEntity *pAttacker ) { #if !defined( CSTRIKE15 ) 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 ); 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" ); #endif } void CFuncTankAPCRocket::Think() { // Inert if we're carried... if ( GetMoveParent() && GetMoveParent()->GetMoveParent() ) { SetNextThink( gpGlobals->curtime + 0.5f ); return; } BaseClass::Think(); #if !defined( CSTRIKE15 ) m_hLaserDot->SetAbsOrigin( m_sightOrigin ); SetLaserDotTarget( m_hLaserDot, m_hFuncTankTarget ); EnableLaserDot( m_hLaserDot, m_hFuncTankTarget != NULL ); #endif 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; } } #if !defined( CSTRIKE15 ) //----------------------------------------------------------------------------- // 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 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" ); 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 ); 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 ); } 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 ) { 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 ); } //----------------------------------------------------------------------------- // 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 ); protected: string_t m_iszBarrelVolume; CHandle 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 ) { // Find our barrel volume if ( !m_hBarrelVolume ) { if ( m_iszBarrelVolume != NULL_STRING ) { m_hBarrelVolume = dynamic_cast( gEntList.FindEntityByName( NULL, m_iszBarrelVolume, NULL ) ); } 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 ); } #endif