//---------------------------------------------------------
//---------------------------------------------------------
void C_ASW_TeslaTrap::UpdateEffects( void )
{
//m_iTrapState = iState;
if ( !m_hEffects && m_bAssembled )
{
Vector vecOrigin;
QAngle vecAngles;
// Get the muzzle origin
if ( !GetAttachment( "effects", vecOrigin, vecAngles ) )
{
vecOrigin = GetAbsOrigin();
vecAngles = QAngle( 0, 0, 0 );
}
m_hEffects = ParticleProp()->Create( "tesla_trap_fx", PATTACH_ABSORIGIN_FOLLOW, -1, vecOrigin - GetAbsOrigin() );
if ( m_hEffects )
{
//m_hEffects->SetSortOrigin( vecOrigin );
//m_hEffects->SetControlPoint( 0, vecOrigin );
Vector vecForward, vecRight, vecUp;
AngleVectors( vecAngles, &vecForward, &vecRight, &vecUp );
m_hEffects->SetControlPointOrientation( 0, vecForward, vecRight, vecUp );
}
}
if ( m_hEffects )
{
switch( m_iTrapState )
{
case TESLATRAP_STATE_DORMANT:
// off
m_hEffects->SetControlPoint( 1, Vector( 0, 0, 0 ) );
//UpdateLight( false, 0, 0, 0, 0 );
break;
case TESLATRAP_STATE_DEPLOY:
// setting up (blue, no ring)
m_hEffects->SetControlPoint( 1, Vector( 0, 0, 0 ) );
//UpdateLight( true, 0, 0, 255, 190 );
break;
case TESLATRAP_STATE_CHARGING:
{
// searching (green glow, red ring)
// TODO: fix this hardcoded recharge time limit
// 3 seconds hardcoded charge time, plus extra time so the scale pops to full from charging so the state is more obvious
float flAmount = 1.0f - ((m_flNextFullChargeTime - gpGlobals->curtime) / (3.0f * 1.5f) );
m_hEffects->SetControlPoint( 1, Vector( flAmount, flAmount, 0 ) );
//UpdateLight( false, 0, 255, 0, 255 );
break;
}
case TESLATRAP_STATE_CHARGED:
// found poetntial enemy (red glow, red ring)
m_hEffects->SetControlPoint( 1, Vector( 1, 1, 0 ) );
//UpdateLight( false, 255, 0, 0, 255 );
break;
default:
DevMsg("**Unknown Trap State: %d\n", m_iTrapState );
break;
}
}
}
bool CFlashlightEffect::ComputeLightPosAndOrientation( const Vector &vecPos, const Vector &vecForward, const Vector &vecRight, const Vector &vecUp,
Vector& vecFinalPos, Quaternion& quatOrientation, bool bTracePlayers )
{
const float flEpsilon = 0.1f; // Offset flashlight position along vecUp
float flDistCutoff = r_flashlighttracedistcutoff.GetFloat();
const float flDistDrag = 0.2;
bool bDebugVis = r_flashlightvisualizetrace.GetBool();
C_BasePlayer *pPlayer = UTIL_PlayerByIndex( m_nEntIndex );
if ( !pPlayer )
{
pPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pPlayer )
{
Assert( false );
return false;
}
}
// We will lock some of the flashlight params if player is on a ladder, to prevent oscillations due to the trace-rays
bool bPlayerOnLadder = ( pPlayer->GetMoveType() == MOVETYPE_LADDER );
CTraceFilterSkipPlayerAndViewModel traceFilter( pPlayer, bTracePlayers );
// Vector vOrigin = vecPos + r_flashlightoffsety.GetFloat() * vecUp;
Vector vecOffset;
pPlayer->GetFlashlightOffset( vecForward, vecRight, vecUp, &vecOffset );
Vector vOrigin = vecPos + vecOffset;
// Not on ladder...trace a hull
if ( !bPlayerOnLadder )
{
Vector vecPlayerEyePos = pPlayer->GetRenderOrigin() + pPlayer->GetViewOffset();
trace_t pmOriginTrace;
UTIL_TraceHull( vecPlayerEyePos, vOrigin, Vector(-2, -2, -2), Vector(2, 2, 2), ( MASK_SOLID & ~(CONTENTS_HITBOX) ) | CONTENTS_WINDOW | CONTENTS_GRATE, &traceFilter, &pmOriginTrace );//1
if ( bDebugVis )
{
debugoverlay->AddBoxOverlay( pmOriginTrace.endpos, Vector( -2, -2, -2 ), Vector( 2, 2, 2 ), QAngle( 0, 0, 0 ), 0, 255, 0, 16, 0 );
if ( pmOriginTrace.DidHit() || pmOriginTrace.startsolid )
{
debugoverlay->AddLineOverlay( pmOriginTrace.startpos, pmOriginTrace.endpos, 255, 128, 128, true, 0 );
}
else
{
debugoverlay->AddLineOverlay( pmOriginTrace.startpos, pmOriginTrace.endpos, 255, 0, 0, true, 0 );
}
}
if ( pmOriginTrace.DidHit() || pmOriginTrace.startsolid )
{
vOrigin = pmOriginTrace.endpos;
}
else
{
if ( pPlayer->m_vecFlashlightOrigin != vecPlayerEyePos )
{
vOrigin = vecPos;
}
}
}
else // on ladder...skip the above hull trace
{
vOrigin = vecPos;
}
// Now do a trace along the flashlight direction to ensure there is nothing within range to pull back from
int iMask = MASK_OPAQUE_AND_NPCS;
iMask &= ~CONTENTS_HITBOX;
iMask |= CONTENTS_WINDOW | CONTENTS_GRATE | CONTENTS_IGNORE_NODRAW_OPAQUE;
Vector vTarget = vOrigin + vecForward * r_flashlightfar.GetFloat();
// Work with these local copies of the basis for the rest of the function
Vector vDir = vTarget - vOrigin;
Vector vRight = vecRight;
Vector vUp = vecUp;
VectorNormalize( vDir );
VectorNormalize( vRight );
VectorNormalize( vUp );
// Orthonormalize the basis, since the flashlight texture projection will require this later...
vUp -= DotProduct( vDir, vUp ) * vDir;
VectorNormalize( vUp );
vRight -= DotProduct( vDir, vRight ) * vDir;
VectorNormalize( vRight );
vRight -= DotProduct( vUp, vRight ) * vUp;
VectorNormalize( vRight );
AssertFloatEquals( DotProduct( vDir, vRight ), 0.0f, 1e-3 );
AssertFloatEquals( DotProduct( vDir, vUp ), 0.0f, 1e-3 );
AssertFloatEquals( DotProduct( vRight, vUp ), 0.0f, 1e-3 );
trace_t pmDirectionTrace;
UTIL_TraceHull( vOrigin, vTarget, Vector( -1.5, -1.5, -1.5 ), Vector( 1.5, 1.5, 1.5 ), iMask, &traceFilter, &pmDirectionTrace );//.5
if ( bDebugVis )
{
debugoverlay->AddBoxOverlay( pmDirectionTrace.endpos, Vector( -4, -4, -4 ), Vector( 4, 4, 4 ), QAngle( 0, 0, 0 ), 0, 0, 255, 16, 0 );
debugoverlay->AddLineOverlay( vOrigin, pmDirectionTrace.endpos, 255, 0, 0, false, 0 );
}
float flTargetPullBackDist = 0.0f;
float flDist = (pmDirectionTrace.endpos - vOrigin).Length();
if ( flDist < flDistCutoff )
{
// We have an intersection with our cutoff range
// Determine how far to pull back, then trace to see if we are clear
float flPullBackDist = bPlayerOnLadder ? r_flashlightladderdist.GetFloat() : flDistCutoff - flDist; // Fixed pull-back distance if on ladder
flTargetPullBackDist = flPullBackDist;
if ( !bPlayerOnLadder )
{
trace_t pmBackTrace;
// start the trace away from the actual trace origin a bit, to avoid getting stuck on small, close "lips"
UTIL_TraceHull( vOrigin - vDir * ( flDistCutoff * r_flashlightbacktraceoffset.GetFloat() ), vOrigin - vDir * ( flPullBackDist - flEpsilon ),
Vector( -1.5f, -1.5f, -1.5f ), Vector( 1.5f, 1.5f, 1.5f ), iMask, &traceFilter, &pmBackTrace );
if ( bDebugVis )
{
debugoverlay->AddLineOverlay( pmBackTrace.startpos, pmBackTrace.endpos, 255, 0, 255, true, 0 );
}
if( pmBackTrace.DidHit() )
{
// We have an intersection behind us as well, so limit our flTargetPullBackDist
float flMaxDist = (pmBackTrace.endpos - vOrigin).Length() - flEpsilon;
flTargetPullBackDist = MIN( flMaxDist, flTargetPullBackDist );
//m_flCurrentPullBackDist = MIN( flMaxDist, m_flCurrentPullBackDist ); // possible pop
}
}
}
if ( bDebugVis )
{
// visualize pullback
debugoverlay->AddBoxOverlay( vOrigin - vDir * m_flCurrentPullBackDist, Vector( -2, -2, -2 ), Vector( 2, 2, 2 ), QAngle( 0, 0, 0 ), 255, 255, 0, 16, 0 );
debugoverlay->AddBoxOverlay( vOrigin - vDir * flTargetPullBackDist, Vector( -1, -1, -1 ), Vector( 1, 1, 1 ), QAngle( 0, 0, 0 ), 128, 128, 0, 16, 0 );
}
m_flCurrentPullBackDist = Lerp( flDistDrag, m_flCurrentPullBackDist, flTargetPullBackDist );
m_flCurrentPullBackDist = MIN( m_flCurrentPullBackDist, flDistCutoff ); // clamp to max pullback dist
vOrigin = vOrigin - vDir * m_flCurrentPullBackDist;
vecFinalPos = vOrigin;
BasisToQuaternion( vDir, vRight, vUp, quatOrientation );
return true;
}
C_RotatingPickup() {
ClientRotAng = QAngle(45,0,0);
m_bRespawning = m_bRespawning_Cache = false;
}
void CWeapon357::PrimaryAttack( void )
{
// Only the player fires this way so we can cast
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if ( !pPlayer )
{
return;
}
if ( m_iClip1 <= 0 )
{
if ( !m_bFireOnEmpty )
{
Reload();
}
else
{
WeaponSound( EMPTY );
m_flNextPrimaryAttack = 0.15;
}
return;
}
m_flNextPrimaryAttack = gpGlobals->curtime + 0.75;
m_flNextSecondaryAttack = gpGlobals->curtime + 0.75;
m_iPrimaryAttacks++;
gamestats->Event_WeaponFired( pPlayer, true, GetClassname() );
WeaponSound( SINGLE );
pPlayer->DoMuzzleFlash();
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
pPlayer->SetAnimation( PLAYER_ATTACK1 );
if (GetWpnData().m_bUseMuzzleSmoke)
{
DispatchParticleEffect("weapon_muzzle_smoke", PATTACH_POINT_FOLLOW, pPlayer->GetViewModel(), "muzzle", true);
}
m_flNextPrimaryAttack = gpGlobals->curtime + 0.75;
m_flNextSecondaryAttack = gpGlobals->curtime + 0.75;
m_iClip1--;
Vector vecSrc = pPlayer->Weapon_ShootPosition();
Vector vecAiming = pPlayer->GetAutoaimVector( AUTOAIM_SCALE_DEFAULT );
pPlayer->FireBullets( 1, vecSrc, vecAiming, vec3_origin, MAX_TRACE_LENGTH, m_iPrimaryAmmoType, 0 );
pPlayer->SetMuzzleFlashTime( gpGlobals->curtime + 0.5 );
//Disorient the player
QAngle angles = pPlayer->GetLocalAngles();
angles.x += random->RandomInt( -1, 1 );
angles.y += random->RandomInt( -1, 1 );
angles.z = 0;
pPlayer->SnapEyeAngles( angles );
pPlayer->ViewPunch( QAngle( -8, random->RandomFloat( -2, 2 ), 0 ) );
CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 600, 0.2, GetOwner() );
if ( !m_iClip1 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
{
// HEV suit - indicate out of ammo condition
pPlayer->SetSuitUpdate( "!HEV_AMO0", FALSE, 0 );
}
}
// this is the think that flips the weapon into the world when it is spawned
void CASW_Laser_Mine::SpawnFlipThink()
{
// we are still flagged as spawn flipping in the air
if ( m_bIsSpawnFlipping == false )
{
// we get here if we spawned, but haven't started spawn flipping yet, please try again!
SetContextThink( &CASW_Laser_Mine::SpawnFlipThink, gpGlobals->curtime, s_pLaserMineSpawnFlipThink );
return;
}
// when we should hit the ground
float flEndTime = m_flSpawnFlipEndTime;
// the total time it takes for us to flip
float flFlipTime = flEndTime - m_flSpawnFlipStartTime;
float flFlipProgress = ( gpGlobals->curtime - m_flSpawnFlipStartTime ) / flFlipTime;
flFlipProgress = clamp( flFlipProgress, 0.0f, 2.5f );
if ( !m_bIsSpawnLanded )
{
// high gravity, it looks more satisfying
float flGravity = 2200;
float flInitialZVelocity = (m_vecSpawnFlipEndPos.z - m_vecSpawnFlipStartPos.z)/flFlipTime + (flGravity/2) * flFlipTime;
float flZVelocity = flInitialZVelocity - flGravity * (gpGlobals->curtime - m_flSpawnFlipStartTime);
float flXDiff = (m_vecSpawnFlipEndPos.x - m_vecSpawnFlipStartPos.x) / flFlipTime;
float flYDiff = (m_vecSpawnFlipEndPos.y - m_vecSpawnFlipStartPos.y) / flFlipTime;
Vector vecVelocity( flXDiff, flYDiff, flZVelocity );
SetAbsVelocity( vecVelocity );
// angular velocity
QAngle angCurAngVel = GetLocalAngularVelocity();
float flXAngDiff = 360 / flFlipTime;
// keep the Y angular velocity that was given to it at the start (it's random)
SetLocalAngularVelocity( QAngle( flXAngDiff, angCurAngVel.y, 0 ) );
}
if ( flFlipProgress >= 1.0f )
{
if ( !m_bIsSpawnLanded )
{
Vector vecVelStop( 0,0,0 );
SetAbsVelocity( vecVelStop );
SetAbsOrigin( m_vecSpawnFlipEndPos );
QAngle angVel( 0, 0, 0 );
SetLocalAngularVelocity( angVel );
/*
// get the current angles of the item so we can use them to determine the final angles
QAngle angPrevAngles = GetAbsAngles();
float flYAngles = angPrevAngles.y;
QAngle angFlat( 0, flYAngles, 0 );
*/
SetAbsAngles( m_angSpawnFlipEndAngle );
EmitSound("ASW_Laser_Mine.Lay");
m_bIsSpawnLanded = true;
}
if ( flFlipProgress >= 2.5f )
{
SetContextThink( NULL, 0, s_pLaserMineSpawnFlipThink );
EmitSound("ASW_Mine.Lay");
m_bMineActive = true;
return;
}
}
SetContextThink( &CASW_Laser_Mine::SpawnFlipThink, gpGlobals->curtime, s_pLaserMineSpawnFlipThink );
}
// apply custom pitch to bone merge
void CASW_Bone_Merge_Cache::MergeMatchingBones( int boneMask, CBoneBitList &boneComputed, bool bOverrideDirection, const Vector &vecDir )
{
UpdateCache();
// If this is set, then all the other cache data is set.
if ( !m_pOwnerHdr || m_MergedBones.Count() == 0 )
return;
// Have the entity we're following setup its bones.
m_pFollow->SetupBones( NULL, -1, m_nFollowBoneSetupMask, gpGlobals->curtime );
matrix3x4_t matPitchUp;
AngleMatrix( QAngle( asw_weapon_pitch.GetFloat(), 0, 0 ), matPitchUp );
// Now copy the bone matrices.
for ( int i=0; i < m_MergedBones.Count(); i++ )
{
int iOwnerBone = m_MergedBones[i].m_iMyBone;
int iParentBone = m_MergedBones[i].m_iParentBone;
// Only update bones reference by the bone mask.
if ( !( m_pOwnerHdr->boneFlags( iOwnerBone ) & boneMask ) )
continue;
if ( bOverrideDirection && m_nRightHandBoneID == -1 ) // only want to change direction of the right hand bone, cache its index here
{
mstudiobone_t *pOwnerBones = m_pOwnerHdr->pBone( 0 );
for ( int k = 0; k < m_pOwnerHdr->numbones(); k++ )
{
if ( !Q_stricmp( pOwnerBones[k].pszName(), "ValveBiped.Bip01_R_Hand" ) )
{
m_nRightHandBoneID = k;
break;
}
}
}
if ( bOverrideDirection && i == m_nRightHandBoneID )
{
matrix3x4_t matParentBoneToWorld;
m_pFollow->GetBoneTransform( iParentBone, matParentBoneToWorld );
MatrixSetColumn( vec3_origin, 3, matParentBoneToWorld ); // remove translation
matrix3x4_t matParentBoneToWorldInv;
MatrixInvert( matParentBoneToWorld, matParentBoneToWorldInv );
QAngle angAiming;
VectorAngles( vecDir, Vector( 0, 0, -1 ), angAiming );
matrix3x4_t matAimDirection;
AngleMatrix( angAiming, matAimDirection );
MatrixSetColumn( vec3_origin, 3, matAimDirection ); // remove translation
matrix3x4_t matCorrection;
ConcatTransforms( matParentBoneToWorldInv, matAimDirection, matCorrection );
ConcatTransforms( m_pFollow->GetBone( iParentBone ), matCorrection, m_pOwner->GetBoneForWrite( iOwnerBone ) );
}
else
{
ConcatTransforms( m_pFollow->GetBone( iParentBone ), matPitchUp, m_pOwner->GetBoneForWrite( iOwnerBone ) );
}
boneComputed.Set( i );
}
}
//-----------------------------------------------------------------------------
// Purpose: Runs movement commands for the player
// Input : *player -
// *ucmd -
// *moveHelper -
// Output : void CPlayerMove::RunCommand
//-----------------------------------------------------------------------------
void CPlayerMove::RunCommand ( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *moveHelper )
{
const float playerCurTime = player->m_nTickBase * TICK_INTERVAL;
const float playerFrameTime = player->m_bGamePaused ? 0 : TICK_INTERVAL;
const float flTimeAllowedForProcessing = player->ConsumeMovementTimeForUserCmdProcessing( playerFrameTime );
if ( !player->IsBot() && ( flTimeAllowedForProcessing < playerFrameTime ) )
{
// Make sure that the activity in command is erased because player cheated or dropped too many packets
double dblWarningFrequencyThrottle = sv_maxusrcmdprocessticks_warning.GetFloat();
if ( dblWarningFrequencyThrottle >= 0 )
{
static double s_dblLastWarningTime = 0;
double dblTimeNow = Plat_FloatTime();
if ( !s_dblLastWarningTime || ( dblTimeNow - s_dblLastWarningTime >= dblWarningFrequencyThrottle ) )
{
s_dblLastWarningTime = dblTimeNow;
Warning( "sv_maxusrcmdprocessticks_warning at server tick %u: Ignored client %s usrcmd (%.6f < %.6f)!\n", gpGlobals->tickcount, player->GetPlayerName(), flTimeAllowedForProcessing, playerFrameTime );
}
}
return; // Don't process this command
}
StartCommand( player, ucmd );
// Set globals appropriately
gpGlobals->curtime = playerCurTime;
gpGlobals->frametime = playerFrameTime;
// Prevent hacked clients from sending us invalid view angles to try to get leaf server code to crash
if ( !ucmd->viewangles.IsValid() || !IsEntityQAngleReasonable(ucmd->viewangles) )
{
ucmd->viewangles = vec3_angle;
}
// Add and subtract buttons we're forcing on the player
ucmd->buttons |= player->m_afButtonForced;
ucmd->buttons &= ~player->m_afButtonDisabled;
if ( player->m_bGamePaused )
{
// If no clipping and cheats enabled and noclipduring game enabled, then leave
// forwardmove and angles stuff in usercmd
if ( player->GetMoveType() == MOVETYPE_NOCLIP &&
sv_cheats->GetBool() &&
sv_noclipduringpause.GetBool() )
{
gpGlobals->frametime = TICK_INTERVAL;
}
}
// Assign the tracked weapon offset
player->m_eyeToWeaponOffset = ucmd->viewToWeaponOffset;
player->m_eyeOffset = ucmd->eyeOffset;
player->m_torsoAngles = QAngle(0, ucmd->torsoYaw, 0);
/*
// TODO: We can check whether the player is sending more commands than elapsed real time
cmdtimeremaining -= ucmd->msec;
if ( cmdtimeremaining < 0 )
{
// return;
}
*/
g_pGameMovement->StartTrackPredictionErrors( player );
CommentarySystem_PePlayerRunCommand( player, ucmd );
// Do weapon selection
if ( ucmd->weaponselect != 0 )
{
CBaseCombatWeapon *weapon = dynamic_cast< CBaseCombatWeapon * >( CBaseEntity::Instance( ucmd->weaponselect ) );
if ( weapon )
{
VPROF( "player->SelectItem()" );
player->SelectItem( weapon->GetName(), ucmd->weaponsubtype );
}
}
IServerVehicle *pVehicle = player->GetVehicle();
// Latch in impulse.
if ( ucmd->impulse )
{
// Discard impulse commands unless the vehicle allows them.
// FIXME: UsingStandardWeapons seems like a bad filter for this. The flashlight is an impulse command, for example.
if ( !pVehicle || player->UsingStandardWeaponsInVehicle() )
{
player->m_nImpulse = ucmd->impulse;
}
}
// Update player input button states
VPROF_SCOPE_BEGIN( "player->UpdateButtonState" );
player->UpdateButtonState( ucmd->buttons );
VPROF_SCOPE_END();
CheckMovingGround( player, TICK_INTERVAL );
g_pMoveData->m_vecOldAngles = player->pl.v_angle;
// Copy from command to player unless game .dll has set angle using fixangle
if ( player->pl.fixangle == FIXANGLE_NONE )
{
player->pl.v_angle = ucmd->viewangles;
}
else if( player->pl.fixangle == FIXANGLE_RELATIVE )
{
player->pl.v_angle = ucmd->viewangles + player->pl.anglechange;
}
// Call standard client pre-think
RunPreThink( player );
// Call Think if one is set
RunThink( player, TICK_INTERVAL );
// Setup input.
SetupMove( player, ucmd, moveHelper, g_pMoveData );
// Let the game do the movement.
if ( !pVehicle )
{
VPROF( "g_pGameMovement->ProcessMovement()" );
Assert( g_pGameMovement );
g_pGameMovement->ProcessMovement( player, g_pMoveData );
}
else
{
VPROF( "pVehicle->ProcessMovement()" );
pVehicle->ProcessMovement( player, g_pMoveData );
}
// Copy output
FinishMove( player, ucmd, g_pMoveData );
// Let server invoke any needed impact functions
VPROF_SCOPE_BEGIN( "moveHelper->ProcessImpacts" );
moveHelper->ProcessImpacts();
VPROF_SCOPE_END();
RunPostThink( player );
g_pGameMovement->FinishTrackPredictionErrors( player );
FinishCommand( player );
// Let time pass
if ( gpGlobals->frametime > 0 )
{
player->m_nTickBase++;
}
}
void CHL2MP_Player::KickAttack(void)
{
if (!IsDead())
{
CBaseViewModel *vm = GetViewModel(1);
if (vm)
{
int idealSequence = vm->SelectWeightedSequence(ACT_VM_PRIMARYATTACK);
if (idealSequence >= 0)
{
vm->SendViewModelMatchingSequence(idealSequence);
m_flNextKickAttack = gpGlobals->curtime + vm->SequenceDuration(idealSequence) - 0.5f;
}
QAngle recoil = QAngle(random->RandomFloat(1.0f, 2.0f), random->RandomFloat(-1.0f, 1.0f), 0);
this->ViewPunch(recoil);
// Trace up or down based on where the enemy is...
// But only if we're basically facing that direction
Vector vecDirection;
int kick_maxrange = 120;
AngleVectors(QAngle(clamp(EyeAngles().x, 20, kick_maxrange), EyeAngles().y, EyeAngles().z), &vecDirection);
CBaseEntity *pEnemy = MyNPCPointer() ? MyNPCPointer()->GetEnemy() : NULL;
if (pEnemy)
{
Vector vecDelta;
VectorSubtract(pEnemy->WorldSpaceCenter(), Weapon_ShootPosition(), vecDelta);
VectorNormalize(vecDelta);
Vector2D vecDelta2D = vecDelta.AsVector2D();
Vector2DNormalize(vecDelta2D);
if (DotProduct2D(vecDelta2D, vecDirection.AsVector2D()) > 0.8f)
{
vecDirection = vecDelta;
}
}
Vector vecEnd;
VectorMA(Weapon_ShootPosition(), 50, vecDirection, vecEnd);
trace_t tr;
UTIL_TraceHull(Weapon_ShootPosition(), vecEnd, Vector(-16, -16, -16), Vector(16, 16, 16), MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, &tr);
// did I hit someone?
float KickDamageMult = 50 + (1 * ((fabs(GetAbsVelocity().x) + fabs(GetAbsVelocity().y) + fabs(GetAbsVelocity().z)) / 48));
float KickThrowForceMult = 20 + (1 * ((fabs(GetAbsVelocity().x) + fabs(GetAbsVelocity().y) + fabs(GetAbsVelocity().z)) / 48));
DevMsg("Kicking at %.2f of damage!\n", KickDamageMult);
DevMsg("Kicking at %.2f of force!\n", KickThrowForceMult);
if (tr.m_pEnt)
{
if (!(tr.m_pEnt))
{
// return;
}
else
{
CBasePropDoor *pDoor = dynamic_cast<CBasePropDoor*>((CBaseEntity*)tr.m_pEnt);
if (pDoor)
{
if (pDoor->HasSpawnFlags(SF_BREAKABLE_BY_PLAYER))
{
AngularImpulse angVelocity(random->RandomFloat(0, 45), 18, random->RandomFloat(-45, 45));
pDoor->PlayBreakOpenSound();
pDoor->BreakDoor(Weapon_ShootPosition(), angVelocity);
return;
}
pDoor->PlayBreakFailSound();
pDoor->KickFail();
return;
}
CBaseEntity *Victim = this->CheckTraceHullAttack(Weapon_ShootPosition(), vecEnd, Vector(-16, -16, -16), Vector(16, 16, 16), KickDamageMult, DMG_CRUSH, KickThrowForceMult, true);
if (Victim)
{
EmitSound("HL2Player.kick_body");
return;
}
}
}
UTIL_TraceLine(Weapon_ShootPosition(), vecEnd, MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, &tr);//IF we hit anything else
if (tr.DidHit())
{
EmitSound("HL2Player.kick_wall");
}
else
{
EmitSound("HL2Player.kick_fire");
}
}
}
}
void CASW_Parasite::InfestMarine(CASW_Marine* pMarine)
{
if ( !pMarine )
return;
pMarine->BecomeInfested(this);
// attach
int attachment = pMarine->LookupAttachment( "chest" );
if ( attachment )
{
SetSolid( SOLID_NONE );
SetMoveType( MOVETYPE_NONE );
QAngle current(0,0,0);
Vector diff = pMarine->GetAbsOrigin() - GetAbsOrigin();
float angle = UTIL_VecToYaw(diff);
angle -= pMarine->GetAbsAngles()[YAW]; // get the diff between our angle from the marine and the marine's facing;
current = GetAbsAngles();
Vector vAttachmentPos;
pMarine->GetAttachment( attachment, vAttachmentPos );
// Make sure it's near the chest attachement before parenting
Teleport( &vAttachmentPos, &vec3_angle, &vec3_origin );
SetParent( pMarine, attachment );
float flRaise = RandomFloat( 15.0f, 18.0f );
float flForward = RandomFloat( -3.0f, 0.0f );
float flSide = RandomFloat( 1.75f, 3.0f ) * ( RandomInt( 0, 1 ) == 0 ? 1.0f : -1.0f );
if ( asw_debug_alien_damage.GetBool() )
{
Msg( "INFEST: flRaise = %f flForward = %f flSide = %f yaw = %f\n", flRaise, flForward, flSide, angle + asw_infest_angle.GetFloat() );
}
SetLocalOrigin( Vector( flForward, flSide, flRaise ) );
SetLocalAngles( QAngle( asw_infest_pitch.GetFloat(), angle + asw_infest_angle.GetFloat(), 0 ) );
// play our infesting anim
if ( asw_parasite_inside.GetBool() )
{
SetActivity(ACT_RANGE_ATTACK2);
}
else
{
int iInfestAttack = LookupSequence("Infest_attack");
if (GetSequence() != iInfestAttack)
{
ResetSequence(iInfestAttack);
}
}
AddFlag( FL_NOTARGET );
SetThink( &CASW_Parasite::InfestThink );
SetTouch( NULL );
m_bInfesting = true;
}
else
{
FinishedInfesting();
}
}
void CNB_Lobby_Tooltip::OnTick()
{
if ( ASWGameRules() && ASWGameRules()->GetCurrentVoteType() != ASW_VOTE_NONE )
{
SetVisible( false );
return;
}
SetVisible( true );
m_bValidTooltip = false;
m_pTitle->SetVisible( false );
int nPromotion = 0;
if ( m_bPromotionTooltip )
{
nPromotion = Briefing()->GetCommanderPromotion( m_nLobbySlot );
}
if ( m_nLobbySlot == -1 || !Briefing()->IsLobbySlotOccupied( m_nLobbySlot ) || ( m_bPromotionTooltip && nPromotion <= 0 ) )
{
m_pTitle->SetVisible( false );
m_pSkillPanel0->SetVisible( false );
m_pSkillPanel1->SetVisible( false );
m_pSkillPanel2->SetVisible( false );
m_pSkillPanel3->SetVisible( false );
m_pSkillPanel4->SetVisible( false );
m_pPromotionIcon->SetVisible( false );
m_pPromotionLabel->SetVisible( false );
m_pItemModelPanel->SetVisible( false );
m_pWeaponDetail0->m_bHidden = true;
m_pWeaponDetail1->m_bHidden = true;
m_pWeaponDetail2->m_bHidden = true;
m_pWeaponDetail3->m_bHidden = true;
m_pWeaponDetail4->m_bHidden = true;
m_pWeaponDetail5->m_bHidden = true;
}
else if ( m_bPromotionTooltip )
{
m_pPromotionIcon->SetVisible( true );
m_pPromotionLabel->SetVisible( true );
m_pSkillPanel0->SetVisible( false );
m_pSkillPanel1->SetVisible( false );
m_pSkillPanel2->SetVisible( false );
m_pSkillPanel3->SetVisible( false );
m_pSkillPanel4->SetVisible( false );
m_pItemModelPanel->SetVisible( false );
m_pWeaponDetail0->m_bHidden = true;
m_pWeaponDetail1->m_bHidden = true;
m_pWeaponDetail2->m_bHidden = true;
m_pWeaponDetail3->m_bHidden = true;
m_pWeaponDetail4->m_bHidden = true;
m_pWeaponDetail5->m_bHidden = true;
m_pTitle->SetVisible( true );
switch( nPromotion )
{
case 1: m_pPromotionLabel->SetText( "#nb_first_promotion" ); m_pTitle->SetText( "#nb_promotion_medal_1"); break;
case 2: m_pPromotionLabel->SetText( "#nb_second_promotion" ); m_pTitle->SetText( "#nb_promotion_medal_2"); break;
case 3: m_pPromotionLabel->SetText( "#nb_third_promotion" ); m_pTitle->SetText( "#nb_promotion_medal_3"); break;
case 4: m_pPromotionLabel->SetText( "#nb_fourth_promotion" ); m_pTitle->SetText( "#nb_promotion_medal_4"); break;
case 5: m_pPromotionLabel->SetText( "#nb_fifth_promotion" ); m_pTitle->SetText( "#nb_promotion_medal_5"); break;
case 6: m_pPromotionLabel->SetText( "#nb_sixth_promotion" ); m_pTitle->SetText( "#nb_promotion_medal_6"); break;
}
m_pPromotionIcon->SetImage( VarArgs( "briefing/promotion_%d_LG", nPromotion ) );
}
else if ( m_bMarineTooltip )
{
CASW_Marine_Profile *pProfile = Briefing()->GetMarineProfile( m_nLobbySlot );
if ( pProfile )
{
m_pTitle->SetVisible( true );
m_pSkillPanel0->SetVisible( true );
m_pSkillPanel1->SetVisible( true );
m_pSkillPanel2->SetVisible( true );
m_pSkillPanel3->SetVisible( true );
m_pSkillPanel4->SetVisible( true );
m_pPromotionIcon->SetVisible( false );
m_pPromotionLabel->SetVisible( false );
m_pWeaponDetail0->m_bHidden = true;
m_pWeaponDetail1->m_bHidden = true;
m_pWeaponDetail2->m_bHidden = true;
m_pWeaponDetail3->m_bHidden = true;
m_pWeaponDetail4->m_bHidden = true;
m_pWeaponDetail5->m_bHidden = true;
m_pItemModelPanel->m_bShouldPaint = false;
m_pItemModelPanel->SetVisible( false );
m_pTitle->SetText( Briefing()->GetMarineName( m_nLobbySlot ) );
m_pSkillPanel0->SetSkillDetails( pProfile->m_ProfileIndex, 0, Briefing()->GetMarineSkillPoints( m_nLobbySlot, 0 ) );
m_pSkillPanel1->SetSkillDetails( pProfile->m_ProfileIndex, 1, Briefing()->GetMarineSkillPoints( m_nLobbySlot, 1 ) );
m_pSkillPanel2->SetSkillDetails( pProfile->m_ProfileIndex, 2, Briefing()->GetMarineSkillPoints( m_nLobbySlot, 2 ) );
m_pSkillPanel3->SetSkillDetails( pProfile->m_ProfileIndex, 3, Briefing()->GetMarineSkillPoints( m_nLobbySlot, 3 ) );
m_pSkillPanel4->SetSkillDetails( pProfile->m_ProfileIndex, 4, Briefing()->GetMarineSkillPoints( m_nLobbySlot, 4 ) );
m_bValidTooltip = true;
}
}
else
{
m_pTitle->SetVisible( true );
m_pSkillPanel0->SetVisible( false );
m_pSkillPanel1->SetVisible( false );
m_pSkillPanel2->SetVisible( false );
m_pSkillPanel3->SetVisible( false );
m_pSkillPanel4->SetVisible( false );
m_pPromotionIcon->SetVisible( false );
m_pPromotionLabel->SetVisible( false );
int nWeapon = Briefing()->GetMarineSelectedWeapon( m_nLobbySlot, m_nInventorySlot );
if ( nWeapon == -1 || !ASWEquipmentList() )
{
m_pTitle->SetVisible( false );
m_pWeaponDetail0->m_bHidden = true;
m_pWeaponDetail1->m_bHidden = true;
m_pWeaponDetail2->m_bHidden = true;
m_pWeaponDetail3->m_bHidden = true;
m_pWeaponDetail4->m_bHidden = true;
m_pWeaponDetail5->m_bHidden = true;
m_pItemModelPanel->m_bShouldPaint = false;
m_pItemModelPanel->SetVisible( false );
return;
}
CASW_EquipItem *pItem = ASWEquipmentList()->GetItemForSlot( m_nInventorySlot, nWeapon );
if ( !pItem )
return;
CASW_WeaponInfo* pWeaponInfo = ASWEquipmentList()->GetWeaponDataFor( STRING( pItem->m_EquipClass ) );
if ( !pWeaponInfo )
return;
bool bShowDetails = ( m_nInventorySlot != ASW_INVENTORY_SLOT_EXTRA && pWeaponInfo->m_flBaseDamage > 0 );
int nWeaponHash = nWeapon * ( m_nInventorySlot + 1 );
bool bWeaponChanged = false;
if ( nWeaponHash != m_nLastWeaponHash || m_nInventorySlot != m_nLastInventorySlot )
{
m_nLastWeaponHash = nWeaponHash;
m_nLastInventorySlot = m_nInventorySlot;
bWeaponChanged = true;
// debug
//Msg( "m_nInventorySlot = %d\nnWeapon = %d\nnWeaponHash = %d\nbShowDetails = %d\n", m_nInventorySlot, nWeapon, nWeaponHash, bShowDetails ? 1 : 0 );
}
if ( bShowDetails )
{
m_pWeaponDetail0->m_bHidden = false;
m_pWeaponDetail1->m_bHidden = false;
m_pWeaponDetail2->m_bHidden = false;
m_pWeaponDetail3->m_bHidden = false;
m_pWeaponDetail4->m_bHidden = false;
m_pWeaponDetail5->m_bHidden = false;
m_pItemModelPanel->m_bShouldPaint = false;
m_pItemModelPanel->SetVisible( false );
}
else
{
m_pWeaponDetail0->m_bHidden = true;
m_pWeaponDetail1->m_bHidden = true;
m_pWeaponDetail2->m_bHidden = true;
m_pWeaponDetail3->m_bHidden = true;
m_pWeaponDetail4->m_bHidden = true;
m_pWeaponDetail5->m_bHidden = false;
Vector vecPos = Vector( -275.0, 0.0, 190.0 );
QAngle angRot = QAngle( 32.0, 0.0, 0.0 );
vecPos.z += pWeaponInfo->m_flModelPanelZOffset;
Vector vecBoundsMins, vecBoundsMax;
m_pItemModelPanel->GetBoundingBox( vecBoundsMins, vecBoundsMax );
int iMaxBounds = -vecBoundsMins.x + vecBoundsMax.x;
iMaxBounds = MAX( iMaxBounds, -vecBoundsMins.y + vecBoundsMax.y );
iMaxBounds = MAX( iMaxBounds, -vecBoundsMins.z + vecBoundsMax.z );
vecPos *= (float)iMaxBounds/64.0f;
m_pItemModelPanel->SetCameraPositionAndAngles( vecPos, angRot );
m_pItemModelPanel->SetModelAnglesAndPosition( QAngle( 0.0f, gpGlobals->curtime * 45.0f , 0.0f ), vec3_origin );
if ( bWeaponChanged )
{
m_pItemModelPanel->ClearMergeMDLs();
if ( Q_stricmp( pWeaponInfo->szDisplayModel, "" ) )
{
m_pItemModelPanel->SetMDL( pWeaponInfo->szDisplayModel );
if ( Q_stricmp( pWeaponInfo->szDisplayModel2, "" ) )
m_pItemModelPanel->SetMergeMDL( pWeaponInfo->szDisplayModel2 );
}
else
{
m_pItemModelPanel->SetMDL( pWeaponInfo->szWorldModel );
}
int nSkin = 0;
if ( pWeaponInfo->m_iDisplayModelSkin > 0 )
nSkin = pWeaponInfo->m_iDisplayModelSkin;
else
nSkin = pWeaponInfo->m_iPlayerModelSkin;
m_pItemModelPanel->SetSkin( nSkin );
m_pItemModelPanel->SetModelAnim( m_pItemModelPanel->FindAnimByName( "idle" ) );
m_pItemModelPanel->m_bShouldPaint = true;
m_pItemModelPanel->SetVisible( true );
// force resetup of various things (this block of code fixes size popping when changing model)
m_pItemModelPanel->InvalidateLayout( true );
m_pItemModelPanel->GetBoundingBox( vecBoundsMins, vecBoundsMax );
int iMaxBounds = -vecBoundsMins.x + vecBoundsMax.x;
iMaxBounds = MAX( iMaxBounds, -vecBoundsMins.y + vecBoundsMax.y );
iMaxBounds = MAX( iMaxBounds, -vecBoundsMins.z + vecBoundsMax.z );
vecPos *= (float)iMaxBounds/64.0f;
m_pItemModelPanel->SetCameraPositionAndAngles( vecPos, angRot );
m_pItemModelPanel->SetModelAnglesAndPosition( QAngle( 0.0f, gpGlobals->curtime * 45.0f , 0.0f ), vec3_origin );
m_pItemModelPanel->InvalidateLayout( true );
m_pItemModelPanel->SetAlpha( 0 );
vgui::GetAnimationController()->RunAnimationCommand( m_pItemModelPanel, "Alpha", 255, 0.01f, 0.5f, vgui::AnimationController::INTERPOLATOR_LINEAR);
}
}
CASW_Marine_Profile *pProfile = Briefing()->GetMarineProfile( m_nLobbySlot );
if ( pProfile )
{
int nProfileIndex = pProfile->m_ProfileIndex;
int nEquipIndex = Briefing()->GetProfileSelectedWeapon( nProfileIndex, m_nInventorySlot );
m_pWeaponDetail0->SetWeaponDetails( nEquipIndex, m_nInventorySlot, nProfileIndex, 0 );
m_pWeaponDetail1->SetWeaponDetails( nEquipIndex, m_nInventorySlot, nProfileIndex, 1 );
m_pWeaponDetail2->SetWeaponDetails( nEquipIndex, m_nInventorySlot, nProfileIndex, 2 );
m_pWeaponDetail3->SetWeaponDetails( nEquipIndex, m_nInventorySlot, nProfileIndex, 3 );
m_pWeaponDetail4->SetWeaponDetails( nEquipIndex, m_nInventorySlot, nProfileIndex, 4 );
m_pWeaponDetail5->SetWeaponDetails( nEquipIndex, m_nInventorySlot, nProfileIndex, 5 );
}
m_pTitle->SetText( pWeaponInfo->szEquipLongName );
m_bValidTooltip = true;
}
}
void CWeaponShotgun::PrimaryAttack( void )
{
// Only the player fires this way so we can cast
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if (!pPlayer)
{
return;
}
if ( m_iClip1 <= 0 )
{
Reload();
if ( m_iClip1 <= 0 )
DryFire( );
return;
}
// MUST call sound before removing a round from the clip of a CMachineGun
WeaponSound( SINGLE );
pPlayer->m_fEffects |= EF_MUZZLEFLASH;
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
pPlayer->SetAnimation( PLAYER_ATTACK1 );
// Don't fire again until fire animation has completed
m_flNextPrimaryAttack = gpGlobals->curtime + 0.75;
m_flNextSecondaryAttack = gpGlobals->curtime + 0.75;
m_iClip1 -= 1;
Vector vecSrc = pPlayer->Weapon_ShootPosition();
Vector vecAiming = pPlayer->GetAutoaimVector( AUTOAIM_5DEGREES );
if ( g_pGameRules->IsMultiplayer() )
{
pPlayer->FireBullets( 4, vecSrc, vecAiming, VECTOR_CONE_DM_SHOTGUN, MAX_TRACE_LENGTH, m_iPrimaryAmmoType, 0 );
}
else
{
pPlayer->FireBullets( 6, vecSrc, vecAiming, VECTOR_CONE_10DEGREES, MAX_TRACE_LENGTH, m_iPrimaryAmmoType, 0 );
}
pPlayer->SetMuzzleFlashTime( gpGlobals->curtime + 1.0 );
pPlayer->ViewPunch( QAngle( -5, 0, 0 ) );
CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 400, 0.2 );
if ( !m_iClip1 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
{
// HEV suit - indicate out of ammo condition
pPlayer->SetSuitUpdate("!HEV_AMO0", FALSE, 0);
}
if ( m_iClip1 > 0 )
{
m_flPumpTime = gpGlobals->curtime + 0.5;
SetWeaponIdleTime( gpGlobals->curtime + 5.0 );
}
else
{
SetWeaponIdleTime( gpGlobals->curtime + 0.75 );
}
m_fInSpecialReload = 0;
}
void CSDKPlayer::FireBullet(
Vector vecSrc, // shooting postion
const QAngle &shootAngles, //shooting angle
float vecSpread, // spread vector
int iDamage, // base damage
int iBulletType, // ammo type
CBaseEntity *pevAttacker, // shooter
bool bDoEffects, // create impact effect ?
float x, // spread x factor
float y // spread y factor
)
{
float fCurrentDamage = iDamage; // damage of the bullet at it's current trajectory
float flCurrentDistance = 0.0; //distance that the bullet has traveled so far
Vector vecDirShooting, vecRight, vecUp;
AngleVectors( shootAngles, &vecDirShooting, &vecRight, &vecUp );
if ( !pevAttacker )
pevAttacker = this; // the default attacker is ourselves
// add the spray
Vector vecDir = vecDirShooting +
x * vecSpread * vecRight +
y * vecSpread * vecUp;
VectorNormalize( vecDir );
float flMaxRange = 8000;
Vector vecEnd = vecSrc + vecDir * flMaxRange; // max bullet range is 10000 units
trace_t tr; // main enter bullet trace
UTIL_TraceLine( vecSrc, vecEnd, MASK_SOLID|CONTENTS_DEBRIS|CONTENTS_HITBOX, this, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction == 1.0f )
return; // we didn't hit anything, stop tracing shoot
if ( sv_showimpacts.GetBool() )
{
#ifdef CLIENT_DLL
// draw red client impact markers
debugoverlay->AddBoxOverlay( tr.endpos, Vector(-2,-2,-2), Vector(2,2,2), QAngle( 0, 0, 0), 255,0,0,127, 4 );
if ( tr.m_pEnt && tr.m_pEnt->IsPlayer() )
{
C_BasePlayer *player = ToBasePlayer( tr.m_pEnt );
player->DrawClientHitboxes( 4, true );
}
#else
// draw blue server impact markers
NDebugOverlay::Box( tr.endpos, Vector(-2,-2,-2), Vector(2,2,2), 0,0,255,127, 4 );
if ( tr.m_pEnt && tr.m_pEnt->IsPlayer() )
{
CBasePlayer *player = ToBasePlayer( tr.m_pEnt );
player->DrawServerHitboxes( 4, true );
}
#endif
}
//calculate the damage based on the distance the bullet travelled.
flCurrentDistance += tr.fraction * flMaxRange;
// damage get weaker of distance
fCurrentDamage *= pow ( 0.85f, (flCurrentDistance / 500));
int iDamageType = DMG_BULLET | DMG_NEVERGIB;
if( bDoEffects )
{
// See if the bullet ended up underwater + started out of the water
if ( enginetrace->GetPointContents( tr.endpos ) & (CONTENTS_WATER|CONTENTS_SLIME) )
{
trace_t waterTrace;
UTIL_TraceLine( vecSrc, tr.endpos, (MASK_SHOT|CONTENTS_WATER|CONTENTS_SLIME), this, COLLISION_GROUP_NONE, &waterTrace );
if( waterTrace.allsolid != 1 )
{
CEffectData data;
data.m_vOrigin = waterTrace.endpos;
data.m_vNormal = waterTrace.plane.normal;
data.m_flScale = random->RandomFloat( 8, 12 );
if ( waterTrace.contents & CONTENTS_SLIME )
{
data.m_fFlags |= FX_WATER_IN_SLIME;
}
DispatchEffect( "gunshotsplash", data );
}
}
else
{
//Do Regular hit effects
// Don't decal nodraw surfaces
if ( !( tr.surface.flags & (SURF_SKY|SURF_NODRAW|SURF_HINT|SURF_SKIP) ) )
{
CBaseEntity *pEntity = tr.m_pEnt;
if ( !( !friendlyfire.GetBool() && pEntity && pEntity->IsPlayer() && pEntity->GetTeamNumber() == GetTeamNumber() ) )
{
UTIL_ImpactTrace( &tr, iDamageType );
}
}
}
} // bDoEffects
// add damage to entity that we hit
#ifdef GAME_DLL
ClearMultiDamage();
CTakeDamageInfo info( pevAttacker, pevAttacker, fCurrentDamage, iDamageType );
CalculateBulletDamageForce( &info, iBulletType, vecDir, tr.endpos );
tr.m_pEnt->DispatchTraceAttack( info, vecDir, &tr );
TraceAttackToTriggers( info, tr.startpos, tr.endpos, vecDir );
ApplyMultiDamage();
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Do the headlight
//-----------------------------------------------------------------------------
void CFlashlightEffect::UpdateLightNew(const Vector &vecPos, const Vector &vecForward, const Vector &vecRight, const Vector &vecUp)
{
FlashlightState_t state;
Vector end = vecPos + r_flashlightoffsety.GetFloat() * vecUp;
trace_t pmEye, pmEyeBack;
CTraceFilterSkipPlayerAndViewModel traceFilter;
UTIL_TraceHull( vecPos, end, Vector( -4, -4, -4 ), Vector ( 4, 4, 4 ), MASK_SOLID & ~(CONTENTS_HITBOX), &traceFilter, &pmEye );
if ( pmEye.fraction != 1.0f )
{
end = vecPos;
}
int iMask = MASK_OPAQUE_AND_NPCS;
iMask &= ~CONTENTS_HITBOX;
iMask |= CONTENTS_WINDOW;
// Trace a line outward, skipping the player model and the view model.
//Eye -> EyeForward
UTIL_TraceHull( end, vecPos + vecForward * r_flashlightfar.GetFloat(), Vector( -4, -4, -4 ), Vector ( 4, 4, 4 ), iMask, &traceFilter, &pmEye );
UTIL_TraceHull( end, vecPos - vecForward * 128, Vector( -4, -4, -4 ), Vector ( 4, 4, 4 ), iMask, &traceFilter, &pmEyeBack );
float flDist;
float flLength = (pmEye.endpos - end).Length();
if ( flLength <= 128 )
{
flDist = ( ( 1.0f - ( flLength / 128 ) ) * 128.0f );
}
else
{
flDist = 0.0f;
}
m_flDistMod = Lerp( 0.3f, m_flDistMod, flDist );
float flMaxDist = (pmEyeBack.endpos - end).Length();
if( m_flDistMod > flMaxDist )
m_flDistMod = flMaxDist;
Vector vStartPos = end;
Vector vEndPos = pmEye.endpos;
Vector vDir = vEndPos - vStartPos;
VectorNormalize( vDir );
if ( vDir == vec3_origin )
{
vDir = vecForward;
}
vStartPos = vStartPos - vDir * m_flDistMod;
if ( r_flashlightvisualizetrace.GetBool() == true )
{
debugoverlay->AddBoxOverlay( vEndPos, Vector( -4, -4, -4 ), Vector( 4, 4, 4 ), QAngle( 0, 0, 0 ), 0, 0, 255, 16, 0 );
debugoverlay->AddLineOverlay( vStartPos, vEndPos, 255, 0, 0, false, 0 );
}
state.m_vecLightOrigin = vStartPos;
state.m_vecLightDirection = vDir;
state.m_fQuadraticAtten = r_flashlightquadratic.GetFloat();
bool bFlicker = false;
#ifdef HL2_EPISODIC
C_BaseHLPlayer *pPlayer = (C_BaseHLPlayer *)C_BasePlayer::GetLocalPlayer();
if ( pPlayer && pPlayer->m_HL2Local.m_flSuitPower <= 10.0f )
{
float flScale = SimpleSplineRemapVal( pPlayer->m_HL2Local.m_flSuitPower, 10.0f, 4.8f, 1.0f, 0.0f );
flScale = clamp( flScale, 0.0f, 1.0f );
if ( flScale < 0.35f )
{
float flFlicker = cosf( gpGlobals->curtime * 6.0f ) * sinf( gpGlobals->curtime * 15.0f );
if ( flFlicker > 0.25f && flFlicker < 0.75f )
{
// On
state.m_fLinearAtten = r_flashlightlinear.GetFloat() * flScale;
}
else
{
// Off
state.m_fLinearAtten = 0.0f;
}
}
else
{
float flNoise = cosf( gpGlobals->curtime * 7.0f ) * sinf( gpGlobals->curtime * 25.0f );
state.m_fLinearAtten = r_flashlightlinear.GetFloat() * flScale + 1.5f * flNoise;
}
state.m_fHorizontalFOVDegrees = r_flashlightfov.GetFloat() - ( 16.0f * (1.0f-flScale) );
state.m_fVerticalFOVDegrees = r_flashlightfov.GetFloat() - ( 16.0f * (1.0f-flScale) );
bFlicker = true;
}
#endif
if ( bFlicker == false )
{
state.m_fLinearAtten = r_flashlightlinear.GetFloat();
state.m_fHorizontalFOVDegrees = r_flashlightfov.GetFloat();
state.m_fVerticalFOVDegrees = r_flashlightfov.GetFloat();
}
state.m_fConstantAtten = r_flashlightconstant.GetFloat();
state.m_Color.Init( 1.0f, 1.0f, 1.0f );
state.m_NearZ = r_flashlightnear.GetFloat();
state.m_FarZ = r_flashlightfar.GetFloat();
if( m_FlashlightHandle == CLIENTSHADOW_INVALID_HANDLE )
{
m_FlashlightHandle = g_pClientShadowMgr->CreateFlashlight( state );
}
else
{
if( !r_flashlightlockposition.GetBool() )
{
g_pClientShadowMgr->UpdateFlashlightState( m_FlashlightHandle, state );
}
}
g_pClientShadowMgr->UpdateProjectedTexture( m_FlashlightHandle, true );
// Kill the old flashlight method if we have one.
LightOffOld();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponAR2::DelayedAttack( void )
{
m_bShotDelayed = false;
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return;
// Deplete the clip completely
SendWeaponAnim( ACT_VM_SECONDARYATTACK );
m_flNextSecondaryAttack = pOwner->m_flNextAttack = gpGlobals->curtime + SequenceDuration();
// Register a muzzleflash for the AI
pOwner->DoMuzzleFlash();
pOwner->SetMuzzleFlashTime( gpGlobals->curtime + 0.5 );
WeaponSound( WPN_DOUBLE );
pOwner->RumbleEffect(RUMBLE_SHOTGUN_DOUBLE, 0, RUMBLE_FLAG_RESTART );
// Fire the bullets
Vector vecSrc = pOwner->Weapon_ShootPosition( );
Vector vecAiming = pOwner->GetAutoaimVector( AUTOAIM_SCALE_DEFAULT );
Vector impactPoint = vecSrc + ( vecAiming * MAX_TRACE_LENGTH );
// Fire the bullets
Vector vecVelocity = vecAiming * 1000.0f;
// Fire the combine ball
CreateCombineBall( vecSrc,
vecVelocity,
sk_weapon_ar2_alt_fire_radius.GetFloat(),
sk_weapon_ar2_alt_fire_mass.GetFloat(),
sk_weapon_ar2_alt_fire_duration.GetFloat(),
pOwner );
// View effects
color32 white = {255, 255, 255, 64};
UTIL_ScreenFade( pOwner, white, 0.1, 0, FFADE_IN );
//Disorient the player
QAngle angles = pOwner->GetLocalAngles();
angles.x += random->RandomInt( -4, 4 );
angles.y += random->RandomInt( -4, 4 );
angles.z = 0;
pOwner->SnapEyeAngles( angles );
pOwner->ViewPunch( QAngle( random->RandomInt( -8, -12 ), random->RandomInt( 1, 2 ), 0 ) );
// Decrease ammo
pOwner->RemoveAmmo( 1, m_iSecondaryAmmoType );
// Can shoot again immediately
m_flNextPrimaryAttack = gpGlobals->curtime + 0.5f;
// Can blow up after a short delay (so have time to release mouse button)
m_flNextSecondaryAttack = gpGlobals->curtime + 1.0f;
}
//-----------------------------------------------------------------------------
// Purpose: Crane rotates around with +left and +right, and extends/retracts
// the cable with +forward and +back.
//-----------------------------------------------------------------------------
void CPropCrane::DriveCrane( int iDriverButtons, int iButtonsPressed, float flNPCSteering )
{
bool bWasExtending = m_bExtending;
// Handle rotation of the crane
if ( iDriverButtons & IN_MOVELEFT )
{
// NPCs may cheat and set the steering
if ( flNPCSteering )
{
m_flTurn = flNPCSteering;
}
else
{
// Try adding some randomness to make it feel shaky?
float flTurnAdd = m_flTurnAccel;
// If we're turning back on ourselves, use decel speed
if ( m_flTurn < 0 )
{
flTurnAdd = MAX( flTurnAdd, m_flTurnDecel );
}
m_flTurn = UTIL_Approach( m_flMaxTurnSpeed, m_flTurn, flTurnAdd * gpGlobals->frametime );
}
m_iTurning = TURNING_LEFT;
}
else if ( iDriverButtons & IN_MOVERIGHT )
{
// NPCs may cheat and set the steering
if ( flNPCSteering )
{
m_flTurn = flNPCSteering;
}
else
{
// Try adding some randomness to make it feel shaky?
float flTurnAdd = m_flTurnAccel;
// If we're turning back on ourselves, increase the rate
if ( m_flTurn > 0 )
{
flTurnAdd = MAX( flTurnAdd, m_flTurnDecel );
}
m_flTurn = UTIL_Approach( -m_flMaxTurnSpeed, m_flTurn, flTurnAdd * gpGlobals->frametime );
}
m_iTurning = TURNING_RIGHT;
}
else
{
m_flTurn = UTIL_Approach( 0, m_flTurn, m_flTurnDecel * gpGlobals->frametime );
m_iTurning = TURNING_NOT;
}
if ( m_hPlayer )
{
float maxTurn = GetMaxTurnRate();
static float maxRumble = 0.35f;
static float minRumble = 0.1f;
float rumbleRange = maxRumble - minRumble;
float rumble;
float factor = fabs(m_flTurn) / maxTurn;
factor = MIN( factor, 1.0f );
rumble = minRumble + (rumbleRange * factor);
m_hPlayer->RumbleEffect( RUMBLE_FLAT_BOTH, (int)(rumble * 100), RUMBLE_FLAG_UPDATE_SCALE );
}
SetLocalAngularVelocity( QAngle(0,m_flTurn * 10,0) );
// Handle extension / retraction of the arm
if ( iDriverButtons & IN_FORWARD )
{
m_flExtensionRate = UTIL_Approach( m_flMaxExtensionSpeed, m_flExtensionRate, m_flExtensionAccel * gpGlobals->frametime );
m_bExtending = true;
}
else if ( iDriverButtons & IN_BACK )
{
m_flExtensionRate = UTIL_Approach( -m_flMaxExtensionSpeed, m_flExtensionRate, m_flExtensionAccel * gpGlobals->frametime );
m_bExtending = true;
}
else
{
m_flExtensionRate = UTIL_Approach( 0, m_flExtensionRate, m_flExtensionDecel * gpGlobals->frametime );
m_bExtending = false;
}
//Msg("Turn: %f\nExtensionRate: %f\n", m_flTurn, m_flExtensionRate );
//If we're holding down an attack button, update our state
if ( iButtonsPressed & (IN_ATTACK | IN_ATTACK2) )
{
// If we have something on the magnet, turn the magnet off
if ( m_hCraneMagnet->GetTotalMassAttachedObjects() )
{
TurnMagnetOff();
}
else if ( !m_bDropping && m_flNextDropAllowedTime < gpGlobals->curtime )
{
TurnMagnetOn();
// Drop the magnet till it hits something
m_bDropping = true;
m_hCraneMagnet->ResetHasHitSomething();
m_hCraneTip->m_pSpring->SetSpringConstant( CRANE_SPRING_CONSTANT_LOWERING );
m_ServerVehicle.PlaySound( VS_MISC1 );
}
}
float flSpeedPercentage = clamp( fabs(m_flTurn) / m_flMaxTurnSpeed, 0, 1 );
vbs_sound_update_t params;
params.Defaults();
params.bThrottleDown = (m_iTurning != TURNING_NOT);
params.flCurrentSpeedFraction = flSpeedPercentage;
params.flWorldSpaceSpeed = 0;
m_ServerVehicle.SoundUpdate( params );
// Play sounds for arm extension / retraction
if ( m_bExtending && !bWasExtending )
{
m_ServerVehicle.StopSound( VS_ENGINE2_STOP );
m_ServerVehicle.PlaySound( VS_ENGINE2_START );
}
else if ( !m_bExtending && bWasExtending )
{
m_ServerVehicle.StopSound( VS_ENGINE2_START );
m_ServerVehicle.PlaySound( VS_ENGINE2_STOP );
}
}
//-----------------------------------------------------------------------------
// Purpose: Called when spawning, after keyvalues have been set.
//-----------------------------------------------------------------------------
void CFuncRotating::Spawn( )
{
#ifdef TF_DLL
AddSpawnFlags( SF_BRUSH_ROTATE_CLIENTSIDE );
#endif
//
// Maintain compatibility with previous maps.
//
if (m_flVolume == 0.0)
{
m_flVolume = 1.0;
}
//
// If the designer didn't set a sound attenuation, default to one.
//
if ( HasSpawnFlags(SF_BRUSH_ROTATE_SMALLRADIUS) )
{
m_flAttenuation = ATTN_IDLE;
}
else if ( HasSpawnFlags(SF_BRUSH_ROTATE_MEDIUMRADIUS) )
{
m_flAttenuation = ATTN_STATIC;
}
else if ( HasSpawnFlags(SF_BRUSH_ROTATE_LARGERADIUS) )
{
m_flAttenuation = ATTN_NORM;
}
else
{
m_flAttenuation = ATTN_NORM;
}
//
// Prevent divide by zero if level designer forgets friction!
//
if ( m_flFanFriction == 0 )
{
m_flFanFriction = 1;
}
//
// Build the axis of rotation based on spawnflags.
//
if ( HasSpawnFlags(SF_BRUSH_ROTATE_Z_AXIS) )
{
m_vecMoveAng = QAngle(0,0,1);
}
else if ( HasSpawnFlags(SF_BRUSH_ROTATE_X_AXIS) )
{
m_vecMoveAng = QAngle(1,0,0);
}
else
{
m_vecMoveAng = QAngle(0,1,0); // y-axis
}
//
// Check for reverse rotation.
//
if ( HasSpawnFlags(SF_BRUSH_ROTATE_BACKWARDS) )
{
m_vecMoveAng = m_vecMoveAng * -1;
}
SetSolid( SOLID_VPHYSICS );
//
// Some rotating objects like fake volumetric lights will not be solid.
//
if ( HasSpawnFlags(SF_ROTATING_NOT_SOLID) )
{
AddSolidFlags( FSOLID_NOT_SOLID );
SetMoveType( MOVETYPE_PUSH );
}
else
{
RemoveSolidFlags( FSOLID_NOT_SOLID );
SetMoveType( MOVETYPE_PUSH );
}
SetModel( STRING( GetModelName() ) );
SetUse( &CFuncRotating::RotatingUse );
//
// Did level designer forget to assign a maximum speed? Prevent a divide by
// zero in RampPitchVol as well as allowing the rotator to work.
//
m_flMaxSpeed = fabs( m_flMaxSpeed );
if (m_flMaxSpeed == 0)
{
m_flMaxSpeed = 100;
}
//
// If the brush should be initially rotating, use it in a little while.
//
if ( HasSpawnFlags(SF_BRUSH_ROTATE_START_ON) )
{
SetThink( &CFuncRotating::SUB_CallUseToggle );
SetNextThink( gpGlobals->curtime + .2 ); // leave a magic delay for client to start up
}
//
// Can this brush inflict pain?
//
if ( HasSpawnFlags(SF_BRUSH_HURT) )
{
SetTouch( &CFuncRotating::HurtTouch );
}
//
// Set speed to 0 in case there's an old "speed" key lying around.
//
m_flSpeed = 0;
Precache( );
CreateVPhysics();
m_angStart = GetLocalAngles();
// Slam the object back to solid - if we really want it to be solid.
if ( m_bSolidBsp )
{
SetSolid( SOLID_BSP );
}
if ( HasSpawnFlags(SF_BRUSH_ROTATE_CLIENTSIDE) )
{
m_vecClientOrigin = GetLocalOrigin();
m_vecClientAngles = GetLocalAngles();
}
}
void CSnark::HuntThink( void )
{
if (!IsInWorld())
{
SetTouch( NULL );
UTIL_Remove( this );
return;
}
StudioFrameAdvance( );
SetNextThink( gpGlobals->curtime + 0.1f );
// explode when ready
if ( gpGlobals->curtime >= m_flDie )
{
g_vecAttackDir = GetAbsVelocity();
VectorNormalize( g_vecAttackDir );
m_iHealth = -1;
CTakeDamageInfo info( this, this, 1, DMG_GENERIC );
Event_Killed( info );
return;
}
// float
if ( GetWaterLevel() != 0)
{
if ( GetMoveType() == MOVETYPE_FLYGRAVITY )
{
SetMoveType( MOVETYPE_FLY, MOVECOLLIDE_FLY_BOUNCE );
}
Vector vecVel = GetAbsVelocity();
vecVel *= 0.9;
vecVel.z += 8.0;
SetAbsVelocity( vecVel );
}
else if ( GetMoveType() == MOVETYPE_FLY )
{
SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
}
// return if not time to hunt
if ( m_flNextHunt > gpGlobals->curtime )
return;
m_flNextHunt = gpGlobals->curtime + 2.0;
Vector vecFlat = GetAbsVelocity();
vecFlat.z = 0;
VectorNormalize( vecFlat );
if ( GetEnemy() == NULL || !GetEnemy()->IsAlive() )
{
// find target, bounce a bit towards it.
GetSenses()->Look( 512 );
SetEnemy( BestEnemy() );
}
// squeek if it's about time blow up
if ( (m_flDie - gpGlobals->curtime <= 0.5) && (m_flDie - gpGlobals->curtime >= 0.3) )
{
CPASAttenuationFilter filter( this );
enginesound->EmitSound( filter, entindex(), CHAN_VOICE, "squeek/sqk_die1.wav", 1, ATTN_NORM, 0, 100 + random->RandomInt( 0, 0x3F ) );
CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 256, 0.25 );
}
// higher pitch as squeeker gets closer to detonation time
float flpitch = 155.0 - 60.0 * ( (m_flDie - gpGlobals->curtime) / SQUEEK_DETONATE_DELAY );
if ( flpitch < 80 )
flpitch = 80;
if ( GetEnemy() != NULL )
{
if ( FVisible( GetEnemy() ) )
{
m_vecTarget = GetEnemy()->EyePosition() - GetAbsOrigin();
VectorNormalize( m_vecTarget );
}
float flVel = GetAbsVelocity().Length();
float flAdj = 50.0 / ( flVel + 10.0 );
if ( flAdj > 1.2 )
flAdj = 1.2;
// ALERT( at_console, "think : enemy\n");
// ALERT( at_console, "%.0f %.2f %.2f %.2f\n", flVel, m_vecTarget.x, m_vecTarget.y, m_vecTarget.z );
SetAbsVelocity( GetAbsVelocity() * flAdj + (m_vecTarget * 300) );
}
if ( GetFlags() & FL_ONGROUND )
{
SetLocalAngularVelocity( QAngle( 0, 0, 0 ) );
}
else
{
QAngle angVel = GetLocalAngularVelocity();
if ( angVel == QAngle( 0, 0, 0 ) )
{
angVel.x = random->RandomFloat( -100, 100 );
angVel.z = random->RandomFloat( -100, 100 );
SetLocalAngularVelocity( angVel );
}
}
if ( ( GetAbsOrigin() - m_posPrev ).Length() < 1.0 )
{
Vector vecVel = GetAbsVelocity();
vecVel.x = random->RandomFloat( -100, 100 );
vecVel.y = random->RandomFloat( -100, 100 );
SetAbsVelocity( vecVel );
}
m_posPrev = GetAbsOrigin();
QAngle angles;
VectorAngles( GetAbsVelocity(), angles );
angles.z = 0;
angles.x = 0;
SetAbsAngles( angles );
}
void C_ASW_Sentry_Top::Scan()
{
C_ASW_Sentry_Base * RESTRICT pBase = GetSentryBase();
if ( !pBase )
{
if ( m_hRadiusDisplay )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_hRadiusDisplay );
m_hRadiusDisplay = NULL;
}
if ( m_hWarningLight )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_hWarningLight );
m_hWarningLight = NULL;
}
return;
}
if ( pBase->GetAmmo() <= 0 )
{
if ( m_hRadiusDisplay )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_hRadiusDisplay );
m_hRadiusDisplay = NULL;
if ( m_hWarningLight )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_hWarningLight );
m_hWarningLight = NULL;
}
if ( !m_hWarningLight )
{
m_hWarningLight = ParticleProp()->Create( "sentry_light_noammo", PATTACH_ABSORIGIN_FOLLOW );
if ( m_hWarningLight )
{
ParticleProp()->AddControlPoint( m_hWarningLight, 0, this, PATTACH_POINT_FOLLOW, "attach_light" );
}
}
}
return;
}
else if ( !m_bLowAmmo && m_hWarningLight )
{
if ( m_hWarningLight )
{
m_hWarningLight->StopEmission(false, false , true);
m_hWarningLight = NULL;
}
}
//if( gpGlobals->curtime >= m_flTimeNextScanPing )
//{
// m_flTimeNextScanPing = gpGlobals->curtime + 1.0f;
//}
QAngle scanAngle;
Vector forward;
Vector vecEye = pBase->GetAbsOrigin() + Vector( 0, 0, 38 );// + m_vecLightOffset;
if ( !m_hRadiusDisplay )
{
// this sets up the outter, "heavier" lines that make up the edges and the middle
m_hRadiusDisplay = ParticleProp()->Create( "sentry_radius_display_beam", PATTACH_CUSTOMORIGIN );
m_hRadiusDisplay->SetControlPoint( 0, vecEye );
// Draw the outer extents
scanAngle = pBase->GetAbsAngles();
scanAngle.y -= GetSentryAngle();
AngleVectors( scanAngle, &forward, NULL, NULL );
CreateRadiusBeamEdges( vecEye, forward, 1 );
scanAngle = pBase->GetAbsAngles();
scanAngle.y += GetSentryAngle();
AngleVectors( scanAngle, &forward, NULL, NULL );
CreateRadiusBeamEdges( vecEye, forward, 2 );
// scanAngle = pBase->GetAbsAngles();
// AngleVectors( scanAngle, &forward, NULL, NULL );
CreateRadiusBeamEdges( vecEye, pBase->Forward(), 3 );
// create the sweeping beam control points
ParticleProp()->AddControlPoint( m_hRadiusDisplay, 4, this, PATTACH_CUSTOMORIGIN );
m_hRadiusDisplay->SetControlPointEntity( 4, this );
ParticleProp()->AddControlPoint( m_hRadiusDisplay, 5, this, PATTACH_CUSTOMORIGIN );
m_hRadiusDisplay->SetControlPointEntity( 5, this );
}
if ( m_hRadiusDisplay )
{
// now move the sweeping beams
QAngle baseAngle = pBase->GetAbsAngles();
baseAngle.y = m_fPrevDeployYaw;
if ( m_fDeployYaw != m_fPrevDeployYaw )
{
//baseAngle.y = Approach( m_fDeployYaw, m_fPrevDeployYaw, 20.0f );
//m_fPrevDeployYaw = baseAngle.y;
float flDeltatime = 1.0f;
float flDir = m_fDeployYaw > m_fPrevDeployYaw ? 1 : -1 ;
float flDist = fabs(m_fDeployYaw - m_fPrevDeployYaw);
if (flDist > 180)
{
flDist = 360 - flDist;
flDir = -flDir;
}
// set our turn rate depending on if we have an enemy or not
float fTurnRate = 10.0f;//ASW_SENTRY_TURNRATE * 0.5f;
if (fabs(flDist) < flDeltatime * fTurnRate)
{
m_fPrevDeployYaw = m_fDeployYaw;
}
else
{
// turn it
m_fPrevDeployYaw += flDeltatime * fTurnRate * flDir;
}
if (m_fPrevDeployYaw < 0)
m_fPrevDeployYaw += 360;
else if (m_fPrevDeployYaw >= 360)
m_fPrevDeployYaw -= 360;
baseAngle.y = m_fPrevDeployYaw;
}
AngleVectors( baseAngle + QAngle( 0, -GetSentryAngle(), 0), &forward, NULL, NULL );
AdjustRadiusBeamEdges( vecEye, forward, 1 );
AngleVectors( baseAngle + QAngle( 0, GetSentryAngle(), 0), &forward, NULL, NULL );
AdjustRadiusBeamEdges( vecEye, forward, 2 );
AngleVectors( baseAngle, &forward, NULL, NULL );
AdjustRadiusBeamEdges( vecEye, forward, 3 );
scanAngle = baseAngle;
scanAngle.y += GetSentryAngle() * sin( gpGlobals->curtime * 3.0f );
Vector vecBase = pBase->GetAbsOrigin() + Vector( 0, 0, 2 );// + m_vecLightOffset;
AngleVectors( scanAngle, &forward, NULL, NULL );
m_hRadiusDisplay->SetControlPoint( 4, vecBase + forward * 190.0f );
m_hRadiusDisplay->SetControlPoint( 5, vecBase + forward * 80.0f );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPlayer -
//-----------------------------------------------------------------------------
void CWeaponBugBait::ThrowGrenade( CBasePlayer *pPlayer )
{
Vector vForward, vRight, vUp, vThrowPos, vThrowVel;
pPlayer->EyeVectors( &vForward, &vRight, &vUp );
vThrowPos = pPlayer->EyePosition();
vThrowPos += vForward * 18.0f;
vThrowPos += vRight * 12.0f;
pPlayer->GetVelocity( &vThrowVel, NULL );
vThrowVel += vForward * 1000;
CGrenadeBugBait *pGrenade = BugBaitGrenade_Create( vThrowPos, vec3_angle, vThrowVel, QAngle(600,random->RandomInt(-1200,1200),0), pPlayer );
if ( pGrenade != NULL )
{
// If the shot is clear to the player, give the missile a grace period
trace_t tr;
UTIL_TraceLine( pPlayer->EyePosition(), pPlayer->EyePosition() + ( vForward * 128 ), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction == 1.0 )
{
pGrenade->SetGracePeriod( 0.1f );
}
}
m_bRedraw = true;
}
//-----------------------------------------------------------------------------
// Purpose: Crane rotates around with +left and +right, and extends/retracts
// the cable with +forward and +back.
//-----------------------------------------------------------------------------
void CPropCannon::DriveCannon( int iDriverButtons, int iButtonsPressed )
{
bool bWasExtending = m_bExtending;
// Handle rotation of the crane
if ( iDriverButtons & IN_MOVELEFT )
{
// Try adding some randomness to make it feel shaky?
float flTurnAdd = m_flTurnAccel;
// If we're turning back on ourselves, use decel speed
if ( m_flTurn < 0 )
{
flTurnAdd = MAX( flTurnAdd, m_flTurnDecel );
}
m_flTurn = UTIL_Approach( m_flMaxTurnSpeed, m_flTurn, flTurnAdd * gpGlobals->frametime );
m_iTurning = CANNON_TURNING_LEFT;
}
else if ( iDriverButtons & IN_MOVERIGHT )
{
// Try adding some randomness to make it feel shaky?
float flTurnAdd = m_flTurnAccel;
// If we're turning back on ourselves, increase the rate
if ( m_flTurn > 0 )
{
flTurnAdd = MAX( flTurnAdd, m_flTurnDecel );
}
m_flTurn = UTIL_Approach( -m_flMaxTurnSpeed, m_flTurn, flTurnAdd * gpGlobals->frametime );
m_iTurning = CANNON_TURNING_RIGHT;
}
else
{
m_flTurn = UTIL_Approach( 0, m_flTurn, m_flTurnDecel * gpGlobals->frametime );
m_iTurning = CANNON_TURNING_NOT;
}
SetLocalAngularVelocity( QAngle(0,m_flTurn * 10,0) );
// Handle extension / retraction of the arm
if ( iDriverButtons & IN_FORWARD )
{
m_flExtensionRate = UTIL_Approach( m_flMaxExtensionSpeed, m_flExtensionRate, m_flExtensionAccel * gpGlobals->frametime );
m_bExtending = true;
}
else if ( iDriverButtons & IN_BACK )
{
m_flExtensionRate = UTIL_Approach( -m_flMaxExtensionSpeed, m_flExtensionRate, m_flExtensionAccel * gpGlobals->frametime );
m_bExtending = true;
}
else
{
m_flExtensionRate = UTIL_Approach( 0, m_flExtensionRate, m_flExtensionDecel * gpGlobals->frametime );
m_bExtending = false;
}
//Msg("Turn: %f\nExtensionRate: %f\n", m_flTurn, m_flExtensionRate );
//If we're holding down an attack button, update our state
if ( iButtonsPressed & (IN_ATTACK | IN_ATTACK2) )
{
if ( m_flNextAttackTime <= gpGlobals->curtime )
{
LaunchProjectile();
}
}
float flSpeedPercentage = clamp( fabs(m_flTurn) / m_flMaxTurnSpeed, 0, 1 );
vbs_sound_update_t params;
params.Defaults();
params.bThrottleDown = (m_iTurning != CANNON_TURNING_NOT);
params.flCurrentSpeedFraction = flSpeedPercentage;
params.flWorldSpaceSpeed = 0;
m_ServerVehicle.SoundUpdate( params );
// Play sounds for arm extension / retraction
if ( m_bExtending && !bWasExtending )
{
m_ServerVehicle.StopSound( VS_ENGINE2_STOP );
m_ServerVehicle.PlaySound( VS_ENGINE2_START );
}
else if ( !m_bExtending && bWasExtending )
{
m_ServerVehicle.StopSound( VS_ENGINE2_START );
m_ServerVehicle.PlaySound( VS_ENGINE2_STOP );
}
}
//-----------------------------------------------------------------------------
// Purpose: Do the headlight
//-----------------------------------------------------------------------------
void CFlashlightEffect::UpdateLightNew(const Vector &vecPos, const Vector &vecForward, const Vector &vecRight, const Vector &vecUp )
{
VPROF_BUDGET( "CFlashlightEffect::UpdateLightNew", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
FlashlightState_t state;
// We will lock some of the flashlight params if player is on a ladder, to prevent oscillations due to the trace-rays
bool bPlayerOnLadder = ( C_BasePlayer::GetLocalPlayer()->GetMoveType() == MOVETYPE_LADDER );
const float flEpsilon = 0.1f; // Offset flashlight position along vecUp
const float flDistCutoff = 128.0f;
const float flDistDrag = 0.2;
CTraceFilterSkipPlayerAndViewModel traceFilter;
float flOffsetY = r_flashlightoffsety.GetFloat();
if( r_swingflashlight.GetBool() )
{
// This projects the view direction backwards, attempting to raise the vertical
// offset of the flashlight, but only when the player is looking down.
Vector vecSwingLight = vecPos + vecForward * -12.0f;
if( vecSwingLight.z > vecPos.z )
{
flOffsetY += (vecSwingLight.z - vecPos.z);
}
}
Vector vOrigin = vecPos + flOffsetY * vecUp;
// Not on ladder...trace a hull
if ( !bPlayerOnLadder )
{
trace_t pmOriginTrace;
UTIL_TraceHull( vecPos, vOrigin, Vector(-4, -4, -4), Vector(4, 4, 4), MASK_SOLID & ~(CONTENTS_HITBOX), &traceFilter, &pmOriginTrace );
if ( pmOriginTrace.DidHit() )
{
vOrigin = vecPos;
}
}
else // on ladder...skip the above hull trace
{
vOrigin = vecPos;
}
// Now do a trace along the flashlight direction to ensure there is nothing within range to pull back from
int iMask = MASK_OPAQUE_AND_NPCS;
iMask &= ~CONTENTS_HITBOX;
iMask |= CONTENTS_WINDOW;
// VR SOURCE - Use weap angle forward vector here
Vector vTarget;
/*if ( VR_Controller()->initialized() && VR_Controller()->hasWeaponTracking() )
{
vTarget = vecPos +
}
else
{*/
vTarget = vecPos + vecForward * r_flashlightfar.GetFloat();
// }
// Work with these local copies of the basis for the rest of the function
Vector vDir = vTarget - vOrigin;
Vector vRight = vecRight;
Vector vUp = vecUp;
VectorNormalize( vDir );
VectorNormalize( vRight );
VectorNormalize( vUp );
// Orthonormalize the basis, since the flashlight texture projection will require this later...
vUp -= DotProduct( vDir, vUp ) * vDir;
VectorNormalize( vUp );
vRight -= DotProduct( vDir, vRight ) * vDir;
VectorNormalize( vRight );
vRight -= DotProduct( vUp, vRight ) * vUp;
VectorNormalize( vRight );
AssertFloatEquals( DotProduct( vDir, vRight ), 0.0f, 1e-3 );
AssertFloatEquals( DotProduct( vDir, vUp ), 0.0f, 1e-3 );
AssertFloatEquals( DotProduct( vRight, vUp ), 0.0f, 1e-3 );
trace_t pmDirectionTrace;
UTIL_TraceHull( vOrigin, vTarget, Vector( -4, -4, -4 ), Vector( 4, 4, 4 ), iMask, &traceFilter, &pmDirectionTrace );
if ( r_flashlightvisualizetrace.GetBool() == true )
{
debugoverlay->AddBoxOverlay( pmDirectionTrace.endpos, Vector( -4, -4, -4 ), Vector( 4, 4, 4 ), QAngle( 0, 0, 0 ), 0, 0, 255, 16, 0 );
debugoverlay->AddLineOverlay( vOrigin, pmDirectionTrace.endpos, 255, 0, 0, false, 0 );
}
float flDist = (pmDirectionTrace.endpos - vOrigin).Length();
if ( flDist < flDistCutoff )
{
// We have an intersection with our cutoff range
// Determine how far to pull back, then trace to see if we are clear
float flPullBackDist = bPlayerOnLadder ? r_flashlightladderdist.GetFloat() : flDistCutoff - flDist; // Fixed pull-back distance if on ladder
m_flDistMod = Lerp( flDistDrag, m_flDistMod, flPullBackDist );
if ( !bPlayerOnLadder )
{
trace_t pmBackTrace;
UTIL_TraceHull( vOrigin, vOrigin - vDir*(flPullBackDist-flEpsilon), Vector( -4, -4, -4 ), Vector( 4, 4, 4 ), iMask, &traceFilter, &pmBackTrace );
if( pmBackTrace.DidHit() )
{
// We have an intersection behind us as well, so limit our m_flDistMod
float flMaxDist = (pmBackTrace.endpos - vOrigin).Length() - flEpsilon;
if( m_flDistMod > flMaxDist )
m_flDistMod = flMaxDist;
}
}
}
else
{
m_flDistMod = Lerp( flDistDrag, m_flDistMod, 0.0f );
}
vOrigin = vOrigin - vDir * m_flDistMod;
state.m_vecLightOrigin = vOrigin;
BasisToQuaternion( vDir, vRight, vUp, state.m_quatOrientation );
state.m_fQuadraticAtten = r_flashlightquadratic.GetFloat();
bool bFlicker = false;
#ifdef HL2_EPISODIC
C_BaseHLPlayer *pPlayer = (C_BaseHLPlayer *)C_BasePlayer::GetLocalPlayer();
if ( pPlayer )
{
float flBatteryPower = ( pPlayer->m_HL2Local.m_flFlashBattery >= 0.0f ) ? ( pPlayer->m_HL2Local.m_flFlashBattery ) : pPlayer->m_HL2Local.m_flSuitPower;
if ( flBatteryPower <= 10.0f )
{
float flScale;
if ( flBatteryPower >= 0.0f )
{
flScale = ( flBatteryPower <= 4.5f ) ? SimpleSplineRemapVal( flBatteryPower, 4.5f, 0.0f, 1.0f, 0.0f ) : 1.0f;
}
else
{
flScale = SimpleSplineRemapVal( flBatteryPower, 10.0f, 4.8f, 1.0f, 0.0f );
}
flScale = clamp( flScale, 0.0f, 1.0f );
if ( flScale < 0.35f )
{
float flFlicker = cosf( gpGlobals->curtime * 6.0f ) * sinf( gpGlobals->curtime * 15.0f );
if ( flFlicker > 0.25f && flFlicker < 0.75f )
{
// On
state.m_fLinearAtten = r_flashlightlinear.GetFloat() * flScale;
}
else
{
// Off
state.m_fLinearAtten = 0.0f;
}
}
else
{
float flNoise = cosf( gpGlobals->curtime * 7.0f ) * sinf( gpGlobals->curtime * 25.0f );
state.m_fLinearAtten = r_flashlightlinear.GetFloat() * flScale + 1.5f * flNoise;
}
state.m_fHorizontalFOVDegrees = r_flashlightfov.GetFloat() - ( 16.0f * (1.0f-flScale) );
state.m_fVerticalFOVDegrees = r_flashlightfov.GetFloat() - ( 16.0f * (1.0f-flScale) );
bFlicker = true;
}
}
#endif // HL2_EPISODIC
if ( bFlicker == false )
{
state.m_fLinearAtten = r_flashlightlinear.GetFloat();
state.m_fHorizontalFOVDegrees = r_flashlightfov.GetFloat();
state.m_fVerticalFOVDegrees = r_flashlightfov.GetFloat();
}
state.m_fConstantAtten = r_flashlightconstant.GetFloat();
state.m_Color[0] = 1.0f;
state.m_Color[1] = 1.0f;
state.m_Color[2] = 1.0f;
state.m_Color[3] = r_flashlightambient.GetFloat();
state.m_NearZ = r_flashlightnear.GetFloat() + m_flDistMod; // Push near plane out so that we don't clip the world when the flashlight pulls back
state.m_FarZ = r_flashlightfar.GetFloat();
state.m_bEnableShadows = r_flashlightdepthtexture.GetBool();
state.m_flShadowMapResolution = r_flashlightdepthres.GetInt();
state.m_pSpotlightTexture = m_FlashlightTexture;
state.m_nSpotlightTextureFrame = 0;
state.m_flShadowAtten = r_flashlightshadowatten.GetFloat();
state.m_flShadowSlopeScaleDepthBias = mat_slopescaledepthbias_shadowmap.GetFloat();
state.m_flShadowDepthBias = mat_depthbias_shadowmap.GetFloat();
if( m_FlashlightHandle == CLIENTSHADOW_INVALID_HANDLE )
{
m_FlashlightHandle = g_pClientShadowMgr->CreateFlashlight( state );
}
else
{
if( !r_flashlightlockposition.GetBool() )
{
g_pClientShadowMgr->UpdateFlashlightState( m_FlashlightHandle, state );
}
}
g_pClientShadowMgr->UpdateProjectedTexture( m_FlashlightHandle, true );
// Kill the old flashlight method if we have one.
LightOffOld();
#ifndef NO_TOOLFRAMEWORK
if ( clienttools->IsInRecordingMode() )
{
KeyValues *msg = new KeyValues( "FlashlightState" );
msg->SetFloat( "time", gpGlobals->curtime );
msg->SetInt( "entindex", m_nEntIndex );
msg->SetInt( "flashlightHandle", m_FlashlightHandle );
msg->SetPtr( "flashlightState", &state );
ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
msg->deleteThis();
}
#endif
}
void CNPC_Hydra::GetDesiredImpaledPosition( Vector *vecOrigin, QAngle *vecAngles )
{
*vecOrigin = m_body[m_body.Count()-2].vecPos;
*vecAngles = QAngle(0,0,0);
}
/*
==============================
CAM_Think
==============================
*/
void CInput::CAM_Think( void )
{
VPROF("CAM_Think");
//
if ( m_pCameraThirdData )
{
return CAM_CameraThirdThink();
}
Vector idealAngles;
Vector camOffset;
float flSensitivity;
QAngle viewangles;
switch( cam_command.GetInt() )
{
case CAM_COMMAND_TOTHIRDPERSON:
CAM_ToThirdPerson();
break;
case CAM_COMMAND_TOFIRSTPERSON:
CAM_ToFirstPerson();
break;
case CAM_COMMAND_NONE:
default:
break;
}
//All this code after this comment has to do with thirdperson
g_ThirdPersonManager.Update();
if( !m_fCameraInThirdPerson )
return;
// In Maya-mode
if ( Is_CAM_ThirdPerson_MayaMode() )
{
// Unless explicitly moving the camera, don't move it
m_fCameraInterceptingMouse = m_fCameraMovingWithMouse =
vgui::input()->IsKeyDown( KEY_LALT ) || vgui::input()->IsKeyDown( KEY_RALT );
if ( !m_fCameraMovingWithMouse )
return;
// Zero-out camera-control kbutton_t structures
memset( &cam_pitchup, 0, sizeof( cam_pitchup ) );
memset( &cam_pitchdown, 0, sizeof( cam_pitchdown ) );
memset( &cam_yawleft, 0, sizeof( cam_yawleft ) );
memset( &cam_yawright, 0, sizeof( cam_yawright ) );
memset( &cam_in, 0, sizeof( cam_in ) );
memset( &cam_out, 0, sizeof( cam_out ) );
// Unless left or right mouse button is down, don't do anything
#ifndef _XBOX
if ( /* Left+Middle Button Down */ vgui::input()->IsMouseDown( MOUSE_LEFT ) && vgui::input()->IsMouseDown( MOUSE_MIDDLE ) )
{
// Do only zoom in/out camera adjustment
m_fCameraDistanceMove = true;
}
else if ( /* Left Button Down */ vgui::input()->IsMouseDown( MOUSE_LEFT ) )
{
// Do only rotational camera movement
m_fCameraDistanceMove = false;
}
else if ( /* Right Button Down */ vgui::input()->IsMouseDown( MOUSE_RIGHT ) )
{
// Do only zoom in/out camera adjustment
m_fCameraDistanceMove = true;
}
else
{
// Neither left or right buttons down, don't do anything
ResetMouse();
return;
}
#endif
}
idealAngles[ PITCH ] = cam_idealpitch.GetFloat();
idealAngles[ YAW ] = cam_idealyaw.GetFloat();
idealAngles[ DIST ] = cam_idealdist.GetFloat();
//
//movement of the camera with the mouse
//
if ( m_fCameraMovingWithMouse )
{
int cpx, cpy;
#ifndef _XBOX
//get windows cursor position
GetMousePos (cpx, cpy);
#else
//xboxfixme
cpx = cpy = 0;
#endif
m_nCameraX = cpx;
m_nCameraY = cpy;
//check for X delta values and adjust accordingly
//eventually adjust YAW based on amount of movement
//don't do any movement of the cam using YAW/PITCH if we are zooming in/out the camera
if (!m_fCameraDistanceMove)
{
int x, y;
GetWindowCenter( x, y );
//keep the camera within certain limits around the player (ie avoid certain bad viewing angles)
if (m_nCameraX>x)
{
//if ((idealAngles[YAW]>=225.0)||(idealAngles[YAW]<135.0))
if (idealAngles[YAW]<c_maxyaw.GetFloat())
{
idealAngles[ YAW ] += (CAM_ANGLE_MOVE)*((m_nCameraX-x)/2);
}
if (idealAngles[YAW]>c_maxyaw.GetFloat())
{
idealAngles[YAW]=c_maxyaw.GetFloat();
}
}
else if (m_nCameraX<x)
{
//if ((idealAngles[YAW]<=135.0)||(idealAngles[YAW]>225.0))
if (idealAngles[YAW]>c_minyaw.GetFloat())
{
idealAngles[ YAW ] -= (CAM_ANGLE_MOVE)* ((x-m_nCameraX)/2);
}
if (idealAngles[YAW]<c_minyaw.GetFloat())
{
idealAngles[YAW]=c_minyaw.GetFloat();
}
}
//check for y delta values and adjust accordingly
//eventually adjust PITCH based on amount of movement
//also make sure camera is within bounds
if (m_nCameraY > y)
{
if(idealAngles[PITCH]<c_maxpitch.GetFloat())
{
idealAngles[PITCH] +=(CAM_ANGLE_MOVE)* ((m_nCameraY-y)/2);
}
if (idealAngles[PITCH]>c_maxpitch.GetFloat())
{
idealAngles[PITCH]=c_maxpitch.GetFloat();
}
}
else if (m_nCameraY<y)
{
if (idealAngles[PITCH]>c_minpitch.GetFloat())
{
idealAngles[PITCH] -= (CAM_ANGLE_MOVE)*((y-m_nCameraY)/2);
}
if (idealAngles[PITCH]<c_minpitch.GetFloat())
{
idealAngles[PITCH]=c_minpitch.GetFloat();
}
}
//set old mouse coordinates to current mouse coordinates
//since we are done with the mouse
if ( ( flSensitivity = gHUD.GetSensitivity() ) != 0 )
{
m_nCameraOldX=m_nCameraX*flSensitivity;
m_nCameraOldY=m_nCameraY*flSensitivity;
}
else
{
m_nCameraOldX=m_nCameraX;
m_nCameraOldY=m_nCameraY;
}
#ifndef _XBOX
ResetMouse();
#endif
}
}
//Nathan code here
if( input->KeyState( &cam_pitchup ) )
idealAngles[ PITCH ] += cam_idealdelta.GetFloat();
else if( input->KeyState( &cam_pitchdown ) )
idealAngles[ PITCH ] -= cam_idealdelta.GetFloat();
if( input->KeyState( &cam_yawleft ) )
idealAngles[ YAW ] -= cam_idealdelta.GetFloat();
else if( input->KeyState( &cam_yawright ) )
idealAngles[ YAW ] += cam_idealdelta.GetFloat();
if( input->KeyState( &cam_in ) )
{
idealAngles[ DIST ] -= 2*cam_idealdelta.GetFloat();
if( idealAngles[ DIST ] < CAM_MIN_DIST )
{
// If we go back into first person, reset the angle
idealAngles[ PITCH ] = 0;
idealAngles[ YAW ] = 0;
idealAngles[ DIST ] = CAM_MIN_DIST;
}
}
else if( input->KeyState( &cam_out ) )
idealAngles[ DIST ] += 2*cam_idealdelta.GetFloat();
if (m_fCameraDistanceMove)
{
int x, y;
GetWindowCenter( x, y );
if (m_nCameraY>y)
{
if(idealAngles[ DIST ]<c_maxdistance.GetFloat())
{
idealAngles[ DIST ] +=cam_idealdelta.GetFloat() * ((m_nCameraY-y)/2);
}
if (idealAngles[ DIST ]>c_maxdistance.GetFloat())
{
idealAngles[ DIST ]=c_maxdistance.GetFloat();
}
}
else if (m_nCameraY<y)
{
if (idealAngles[ DIST ]>c_mindistance.GetFloat())
{
idealAngles[ DIST ] -= (cam_idealdelta.GetFloat())*((y-m_nCameraY)/2);
}
if (idealAngles[ DIST ]<c_mindistance.GetFloat())
{
idealAngles[ DIST ]=c_mindistance.GetFloat();
}
}
//set old mouse coordinates to current mouse coordinates
//since we are done with the mouse
m_nCameraOldX=m_nCameraX*gHUD.GetSensitivity();
m_nCameraOldY=m_nCameraY*gHUD.GetSensitivity();
#ifndef _XBOX
ResetMouse();
#endif
}
// Obtain engine view angles and if they popped while the camera was static,
// fix the camera angles as well
engine->GetViewAngles( viewangles );
static QAngle s_oldAngles = viewangles;
if ( Is_CAM_ThirdPerson_MayaMode() && ( s_oldAngles != viewangles ) )
{
idealAngles[ PITCH ] += s_oldAngles[ PITCH ] - viewangles[ PITCH ];
idealAngles[ YAW ] += s_oldAngles[ YAW ] - viewangles[ YAW ];
s_oldAngles = viewangles;
}
// bring the pitch values back into a range that MoveToward can handle
if ( idealAngles[ PITCH ] > 180 )
idealAngles[ PITCH ] -= 360;
else if ( idealAngles[ PITCH ] < -180 )
idealAngles[ PITCH ] += 360;
// bring the yaw values back into a range that MoveToward can handle
// --
// Vitaliy: going with >= 180 and <= -180.
// This introduces a potential discontinuity when looking directly at model face
// as camera yaw will be jumping from +180 to -180 and back, but when working with
// the camera allows smooth rotational transitions from left to right and back.
// Otherwise one of the transitions that has ">"-comparison will be locked.
// --
if ( idealAngles[ YAW ] >= 180 )
idealAngles[ YAW ] -= 360;
else if ( idealAngles[ YAW ] <= -180 )
idealAngles[ YAW ] += 360;
// clamp pitch, yaw and dist...
idealAngles[ PITCH ] = clamp( idealAngles[ PITCH ], c_minpitch.GetFloat(), c_maxpitch.GetFloat() );
idealAngles[ YAW ] = clamp( idealAngles[ YAW ], c_minyaw.GetFloat(), c_maxyaw.GetFloat() );
idealAngles[ DIST ] = clamp( idealAngles[ DIST ], c_mindistance.GetFloat(), c_maxdistance.GetFloat() );
// update ideal angles
cam_idealpitch.SetValue( idealAngles[ PITCH ] );
cam_idealyaw.SetValue( idealAngles[ YAW ] );
cam_idealdist.SetValue( idealAngles[ DIST ] );
// Move the CameraOffset "towards" the idealAngles
// Note: CameraOffset = viewangle + idealAngle
VectorCopy( g_ThirdPersonManager.GetCameraOffsetAngles(), camOffset );
if( cam_snapto.GetInt() )
{
camOffset[ YAW ] = cam_idealyaw.GetFloat() + viewangles[ YAW ];
camOffset[ PITCH ] = cam_idealpitch.GetFloat() + viewangles[ PITCH ];
camOffset[ DIST ] = cam_idealdist.GetFloat();
}
else
{
float lag = MAX( 1, 1 + cam_ideallag.GetFloat() );
if( camOffset[ YAW ] - viewangles[ YAW ] != cam_idealyaw.GetFloat() )
camOffset[ YAW ] = MoveToward( camOffset[ YAW ], cam_idealyaw.GetFloat() + viewangles[ YAW ], lag );
if( camOffset[ PITCH ] - viewangles[ PITCH ] != cam_idealpitch.GetFloat() )
camOffset[ PITCH ] = MoveToward( camOffset[ PITCH ], cam_idealpitch.GetFloat() + viewangles[ PITCH ], lag );
if( abs( camOffset[ DIST ] - cam_idealdist.GetFloat() ) < 2.0 )
camOffset[ DIST ] = cam_idealdist.GetFloat();
else
camOffset[ DIST ] += ( cam_idealdist.GetFloat() - camOffset[ DIST ] ) / lag;
}
// move the camera closer to the player if it hit something
if ( cam_collision.GetInt() )
{
QAngle desiredCamAngles = QAngle( camOffset[ PITCH ], camOffset[ YAW ], camOffset[ DIST ] );
if ( g_ThirdPersonManager.IsOverridingThirdPerson() == false )
{
desiredCamAngles = viewangles;
}
g_ThirdPersonManager.PositionCamera( C_BasePlayer::GetLocalPlayer(), desiredCamAngles );
}
if ( cam_showangles.GetInt() )
{
engine->Con_NPrintf( 4, "Pitch: %6.1f Yaw: %6.1f %38s", viewangles[ PITCH ], viewangles[ YAW ], "view angles" );
engine->Con_NPrintf( 6, "Pitch: %6.1f Yaw: %6.1f Dist: %6.1f %19s", cam_idealpitch.GetFloat(), cam_idealyaw.GetFloat(), cam_idealdist.GetFloat(), "ideal angles" );
engine->Con_NPrintf( 8, "Pitch: %6.1f Yaw: %6.1f Dist: %6.1f %16s", g_ThirdPersonManager.GetCameraOffsetAngles()[ PITCH ], g_ThirdPersonManager.GetCameraOffsetAngles()[ YAW ], g_ThirdPersonManager.GetCameraOffsetAngles()[ DIST ], "camera offset" );
}
//g_ThirdPersonManager.SetCameraOffsetAngles( camOffset );
g_ThirdPersonManager.SetCameraOffsetAngles(camOffset);
}
//=========================================================
// SonicAttack
//=========================================================
void CNPC_Houndeye::SonicAttack ( void )
{
EmitSound( "NPC_Houndeye.SonicAttack" );
if (m_pEnergyWave)
{
UTIL_Remove(m_pEnergyWave);
}
Vector vFacingDir = EyeDirection3D( );
m_pEnergyWave = (CEnergyWave*)Create( "energy_wave", EyePosition(), GetLocalAngles() );
m_flEndEnergyWaveTime = gpGlobals->curtime + 1; //<<TEMP>> magic
m_pEnergyWave->SetAbsVelocity( 100*vFacingDir );
CBaseEntity *pEntity = NULL;
// iterate on all entities in the vicinity.
for ( CEntitySphereQuery sphere( GetAbsOrigin(), HOUNDEYE_MAX_ATTACK_RADIUS ); pEntity = sphere.GetCurrentEntity(); sphere.NextEntity() )
{
if (pEntity->Classify() == CLASS_HOUNDEYE)
{
continue;
}
if (pEntity->GetFlags() & FL_NOTARGET)
{
continue;
}
IPhysicsObject *pPhysicsObject = pEntity->VPhysicsGetObject();
if ( pEntity->m_takedamage != DAMAGE_NO || pPhysicsObject)
{
// --------------------------
// Adjust damage by distance
// --------------------------
float flDist = (pEntity->WorldSpaceCenter() - GetAbsOrigin()).Length();
float flDamageAdjuster = 1-( flDist / HOUNDEYE_MAX_ATTACK_RADIUS );
// --------------------------
// Adjust damage by direction
// --------------------------
Vector forward;
AngleVectors( GetAbsAngles(), &forward );
Vector vEntDir = (pEntity->GetAbsOrigin() - GetAbsOrigin());
VectorNormalize(vEntDir);
float flDotPr = DotProduct(forward,vEntDir);
flDamageAdjuster *= flDotPr;
if (flDamageAdjuster < 0)
{
continue;
}
// --------------------------
// Adjust damage by visibility
// --------------------------
if ( !FVisible( pEntity ) )
{
if ( pEntity->IsPlayer() )
{
// if this entity is a client, and is not in full view, inflict half damage. We do this so that players still
// take the residual damage if they don't totally leave the houndeye's effective radius. We restrict it to clients
// so that monsters in other parts of the level don't take the damage and get pissed.
flDamageAdjuster *= 0.5;
}
else if ( !FClassnameIs( pEntity, "func_breakable" ) && !FClassnameIs( pEntity, "func_pushable" ) )
{
// do not hurt nonclients through walls, but allow damage to be done to breakables
continue;
}
}
// ------------------------------
// Apply the damage
// ------------------------------
if (pEntity->m_takedamage != DAMAGE_NO)
{
CTakeDamageInfo info( this, this, flDamageAdjuster * sk_Houndeye_dmg_blast.GetFloat(), DMG_SONIC | DMG_ALWAYSGIB );
CalculateExplosiveDamageForce( &info, (pEntity->GetAbsOrigin() - GetAbsOrigin()), pEntity->GetAbsOrigin() );
pEntity->TakeDamage( info );
// Throw the player
if ( pEntity->IsPlayer() )
{
Vector forward;
AngleVectors( GetLocalAngles(), &forward );
Vector vecVelocity = pEntity->GetAbsVelocity();
vecVelocity += forward * 250 * flDamageAdjuster;
vecVelocity.z = 300 * flDamageAdjuster;
pEntity->SetAbsVelocity( vecVelocity );
pEntity->ViewPunch( QAngle(random->RandomInt(-20,20), 0, random->RandomInt(-20,20)) );
}
}
// ------------------------------
// Apply physics foces
// ------------------------------
IPhysicsObject *pPhysicsObject = pEntity->VPhysicsGetObject();
if (pPhysicsObject)
{
float flForce = flDamageAdjuster * 8000;
pPhysicsObject->ApplyForceCenter( (vEntDir+Vector(0,0,0.2)) * flForce );
pPhysicsObject->ApplyTorqueCenter( vEntDir * flForce );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Moves the client pitch angle towards cl.idealpitch sent by the server.
// If the user is adjusting pitch manually, either with lookup/lookdown,
// mlook and mouse, or klook and keyboard, pitch drifting is constantly stopped.
//-----------------------------------------------------------------------------
void CViewRender::DriftPitch (void)
{
float delta, move;
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
if ( !player )
return;
#if defined( REPLAY_ENABLED )
if ( engine->IsHLTV() || g_pEngineClientReplay->IsPlayingReplayDemo() || ( player->GetGroundEntity() == NULL ) || engine->IsPlayingDemo() )
#else
if ( engine->IsHLTV() || ( player->GetGroundEntity() == NULL ) || engine->IsPlayingDemo() )
#endif
{
m_PitchDrift.driftmove = 0;
m_PitchDrift.pitchvel = 0;
return;
}
// Don't count small mouse motion
if ( m_PitchDrift.nodrift )
{
if ( fabs( input->GetLastForwardMove() ) < cl_forwardspeed.GetFloat() )
{
m_PitchDrift.driftmove = 0;
}
else
{
m_PitchDrift.driftmove += gpGlobals->frametime;
}
if ( m_PitchDrift.driftmove > v_centermove.GetFloat() )
{
StartPitchDrift ();
}
return;
}
// How far off are we
delta = prediction->GetIdealPitch() - player->GetAbsAngles()[ PITCH ];
if ( !delta )
{
m_PitchDrift.pitchvel = 0;
return;
}
// Determine movement amount
move = gpGlobals->frametime * m_PitchDrift.pitchvel;
// Accelerate
m_PitchDrift.pitchvel += gpGlobals->frametime * v_centerspeed.GetFloat();
// Move predicted pitch appropriately
if (delta > 0)
{
if ( move > delta )
{
m_PitchDrift.pitchvel = 0;
move = delta;
}
player->SetLocalAngles( player->GetLocalAngles() + QAngle( move, 0, 0 ) );
}
else if ( delta < 0 )
{
if ( move > -delta )
{
m_PitchDrift.pitchvel = 0;
move = -delta;
}
player->SetLocalAngles( player->GetLocalAngles() - QAngle( move, 0, 0 ) );
}
}
//-----------------------------------------------------------------------------
// Purpose: Override for backpeddling
// Input : dt -
//-----------------------------------------------------------------------------
void CBasePlayerAnimState::ComputePoseParam_MoveYaw( CStudioHdr *pStudioHdr )
{
VPROF( "CBasePlayerAnimState::ComputePoseParam_MoveYaw" );
//Matt: Goldsrc style animations need to not rotate the model
if ( m_AnimConfig.m_LegAnimType == LEGANIM_GOLDSRC )
{
#ifndef CLIENT_DLL
//Adrian: Make the model's angle match the legs so the hitboxes match on both sides.
GetOuter()->SetLocalAngles( QAngle( 0, m_flCurrentFeetYaw, 0 ) );
#endif
}
// If using goldsrc-style animations where he's moving in the direction that his feet are facing,
// we don't use move yaw.
if ( m_AnimConfig.m_LegAnimType != LEGANIM_9WAY && m_AnimConfig.m_LegAnimType != LEGANIM_8WAY )
return;
// view direction relative to movement
float flYaw;
EstimateYaw();
float ang = m_flEyeYaw;
if ( ang > 180.0f )
{
ang -= 360.0f;
}
else if ( ang < -180.0f )
{
ang += 360.0f;
}
// calc side to side turning
flYaw = ang - m_flGaitYaw;
// Invert for mapping into 8way blend
flYaw = -flYaw;
flYaw = flYaw - (int)(flYaw / 360) * 360;
if (flYaw < -180)
{
flYaw = flYaw + 360;
}
else if (flYaw > 180)
{
flYaw = flYaw - 360;
}
if ( m_AnimConfig.m_LegAnimType == LEGANIM_9WAY )
{
#ifndef CLIENT_DLL
//Adrian: Make the model's angle match the legs so the hitboxes match on both sides.
GetOuter()->SetLocalAngles( QAngle( 0, m_flCurrentFeetYaw, 0 ) );
#endif
int iMoveX = GetOuter()->LookupPoseParameter( pStudioHdr, "move_x" );
int iMoveY = GetOuter()->LookupPoseParameter( pStudioHdr, "move_y" );
if ( iMoveX < 0 || iMoveY < 0 )
return;
bool bIsMoving;
float flPlaybackRate = CalcMovementPlaybackRate( &bIsMoving );
// Setup the 9-way blend parameters based on our speed and direction.
Vector2D vCurMovePose( 0, 0 );
if ( bIsMoving )
{
vCurMovePose.x = cos( DEG2RAD( flYaw ) ) * flPlaybackRate;
vCurMovePose.y = -sin( DEG2RAD( flYaw ) ) * flPlaybackRate;
}
GetOuter()->SetPoseParameter( pStudioHdr, iMoveX, vCurMovePose.x );
GetOuter()->SetPoseParameter( pStudioHdr, iMoveY, vCurMovePose.y );
m_vLastMovePose = vCurMovePose;
}
else
{
int iMoveYaw = GetOuter()->LookupPoseParameter( pStudioHdr, "move_yaw" );
if ( iMoveYaw >= 0 )
{
GetOuter()->SetPoseParameter( pStudioHdr, iMoveYaw, flYaw );
m_flLastMoveYaw = flYaw;
// Now blend in his idle animation.
// This makes the 8-way blend act like a 9-way blend by blending to
// an idle sequence as he slows down.
#if defined(CLIENT_DLL)
#ifndef INFESTED_DLL
bool bIsMoving;
CAnimationLayer *pLayer = m_pOuter->GetAnimOverlay( MAIN_IDLE_SEQUENCE_LAYER );
pLayer->SetWeight( 1 - CalcMovementPlaybackRate( &bIsMoving ) );
if ( !bIsMoving )
{
pLayer->SetWeight( 1 );
}
if ( ShouldChangeSequences() )
{
// Whenever this layer stops blending, we can choose a new idle sequence to blend to, so he
// doesn't always use the same idle.
if ( pLayer->GetWeight() < 0.02f || m_iCurrent8WayIdleSequence == -1 )
{
m_iCurrent8WayIdleSequence = m_pOuter->SelectWeightedSequence( ACT_IDLE );
m_iCurrent8WayCrouchIdleSequence = m_pOuter->SelectWeightedSequence( ACT_CROUCHIDLE );
}
if ( m_eCurrentMainSequenceActivity == ACT_CROUCHIDLE || m_eCurrentMainSequenceActivity == ACT_RUN_CROUCH )
pLayer->SetSequence( m_iCurrent8WayCrouchIdleSequence );
else
pLayer->SetSequence( m_iCurrent8WayIdleSequence );
}
pLayer->SetPlaybackRate( 1 );
pLayer->SetCycle( pLayer->GetCycle() + m_pOuter->GetSequenceCycleRate( pStudioHdr, pLayer->GetSequence() ) * gpGlobals->frametime );
pLayer->SetCycle( fmod( pLayer->GetCycle(), 1 ) );
pLayer->SetOrder( MAIN_IDLE_SEQUENCE_LAYER );
#endif
#endif
}
}
}
void CWeaponStunStick::Operator_HandleAnimEvent( animevent_t *pEvent, CBaseCombatCharacter *pOperator )
{
switch( pEvent->event )
{
case EVENT_WEAPON_MELEE_HIT:
{
// Trace up or down based on where the enemy is...
// But only if we're basically facing that direction
Vector vecDirection;
AngleVectors( GetAbsAngles(), &vecDirection );
CBaseEntity *pEnemy = pOperator->MyNPCPointer() ? pOperator->MyNPCPointer()->GetEnemy() : NULL;
if ( pEnemy )
{
Vector vecDelta;
VectorSubtract( pEnemy->WorldSpaceCenter(), pOperator->Weapon_ShootPosition(), vecDelta );
VectorNormalize( vecDelta );
Vector2D vecDelta2D = vecDelta.AsVector2D();
Vector2DNormalize( vecDelta2D );
if ( DotProduct2D( vecDelta2D, vecDirection.AsVector2D() ) > 0.8f )
{
vecDirection = vecDelta;
}
}
Vector vecEnd;
VectorMA( pOperator->Weapon_ShootPosition(), 32, vecDirection, vecEnd );
// Stretch the swing box down to catch low level physics objects
CBaseEntity *pHurt = pOperator->CheckTraceHullAttack( pOperator->Weapon_ShootPosition(), vecEnd,
Vector(-16,-16,-40), Vector(16,16,16), GetDamageForActivity( GetActivity() ), DMG_CLUB, 0.5f, false );
// did I hit someone?
if ( pHurt )
{
// play sound
WeaponSound( MELEE_HIT );
CBasePlayer *pPlayer = ToBasePlayer( pHurt );
CNPC_MetroPolice *pCop = dynamic_cast<CNPC_MetroPolice *>(pOperator);
bool bFlashed = false;
if ( pCop != NULL && pPlayer != NULL )
{
// See if we need to knock out this target
if ( pCop->ShouldKnockOutTarget( pHurt ) )
{
float yawKick = random->RandomFloat( -48, -24 );
//Kick the player angles
pPlayer->ViewPunch( QAngle( -16, yawKick, 2 ) );
color32 white = {255,255,255,255};
UTIL_ScreenFade( pPlayer, white, 0.2f, 1.0f, FFADE_OUT|FFADE_PURGE|FFADE_STAYOUT );
bFlashed = true;
pCop->KnockOutTarget( pHurt );
break;
}
else
{
// Notify that we've stunned a target
pCop->StunnedTarget( pHurt );
}
}
// Punch angles
if ( pPlayer != NULL && !(pPlayer->GetFlags() & FL_GODMODE) )
{
float yawKick = random->RandomFloat( -48, -24 );
//Kick the player angles
pPlayer->ViewPunch( QAngle( -16, yawKick, 2 ) );
Vector dir = pHurt->GetAbsOrigin() - GetAbsOrigin();
// If the player's on my head, don't knock him up
if ( pPlayer->GetGroundEntity() == pOperator )
{
dir = vecDirection;
dir.z = 0;
}
VectorNormalize(dir);
dir *= 500.0f;
//If not on ground, then don't make them fly!
if ( !(pPlayer->GetFlags() & FL_ONGROUND ) )
dir.z = 0.0f;
//Push the target back
pHurt->ApplyAbsVelocityImpulse( dir );
if ( !bFlashed )
{
color32 red = {128,0,0,128};
UTIL_ScreenFade( pPlayer, red, 0.5f, 0.1f, FFADE_IN );
}
// Force the player to drop anyting they were holding
pPlayer->ForceDropOfCarriedPhysObjects();
}
// do effect?
}
else
{
WeaponSound( MELEE_MISS );
}
}
break;
default:
BaseClass::Operator_HandleAnimEvent( pEvent, pOperator );
break;
}
}
virtual QAngle PreferredCarryAngles( void ) { return QAngle( 180, -90, 180 ); }
bool ShouldRemoveThisRagdoll( CBaseAnimating *pRagdoll )
{
if ( g_RagdollLVManager.IsLowViolence() )
{
return true;
}
#ifdef CLIENT_DLL
/* we no longer ignore enemies just because they are on fire -- a ragdoll in front of me
is always a higher priority for retention than a flaming zombie behind me. At the
time I put this in, the ragdolls do clean up their own effects if culled via SUB_Remove().
If you're encountering trouble with ragdolls leaving effects behind, try renabling the code below.
/////////////////////
//Just ignore it until we're done burning/dissolving.
if ( pRagdoll->GetEffectEntity() )
return false;
*/
Vector vMins, vMaxs;
Vector origin = pRagdoll->m_pRagdoll->GetRagdollOrigin();
pRagdoll->m_pRagdoll->GetRagdollBounds( vMins, vMaxs );
if( engine->IsBoxInViewCluster( vMins + origin, vMaxs + origin) == false )
{
if ( g_debug_ragdoll_removal.GetBool() )
{
debugoverlay->AddBoxOverlay( origin, vMins, vMaxs, QAngle( 0, 0, 0 ), 0, 255, 0, 16, 5 );
debugoverlay->AddLineOverlay( origin, origin + Vector( 0, 0, 64 ), 0, 255, 0, true, 5 );
}
return true;
}
else if( engine->CullBox( vMins + origin, vMaxs + origin ) == true )
{
if ( g_debug_ragdoll_removal.GetBool() )
{
debugoverlay->AddBoxOverlay( origin, vMins, vMaxs, QAngle( 0, 0, 0 ), 0, 0, 255, 16, 5 );
debugoverlay->AddLineOverlay( origin, origin + Vector( 0, 0, 64 ), 0, 0, 255, true, 5 );
}
return true;
}
#else
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
if( !UTIL_FindClientInPVS( pRagdoll->edict() ) )
{
if ( g_debug_ragdoll_removal.GetBool() )
NDebugOverlay::Line( pRagdoll->GetAbsOrigin(), pRagdoll->GetAbsOrigin() + Vector( 0, 0, 64 ), 0, 255, 0, true, 5 );
return true;
}
else if( !pPlayer->FInViewCone( pRagdoll ) )
{
if ( g_debug_ragdoll_removal.GetBool() )
NDebugOverlay::Line( pRagdoll->GetAbsOrigin(), pRagdoll->GetAbsOrigin() + Vector( 0, 0, 64 ), 0, 0, 255, true, 5 );
return true;
}
#endif
return false;
}
//-----------------------------------------------------------------------------
// Creates a single sfm file
//-----------------------------------------------------------------------------
void CSFMGenApp::GenerateSFMFile( const SFMGenInfo_t& sfmGenInfo, const SFMInfo_t &info,
studiohdr_t *pStudioHdr, const char *pOutputDirectory, const char *pExportFacPath )
{
CSFMSession session;
session.Init();
char pAnimationSetName[256];
Q_FileBase( pStudioHdr->name, pAnimationSetName, sizeof(pAnimationSetName) );
// Set the file id( necessary for phoneme extraction)
DmFileId_t fileid = g_pDataModel->FindOrCreateFileId( pAnimationSetName );
session.Root()->SetFileId( fileid, TD_DEEP );
g_pModelPresetGroupMgr->AssociatePresetsWithFile( fileid );
// Get the shot.
CDmeFilmClip *pMovie = session.Root()->GetValueElement<CDmeFilmClip>( "activeClip" );
CDmeFilmClip* pShot = CastElement< CDmeFilmClip >( pMovie->GetFilmTrack()->GetClip( 0 ) );
// Create a camera for the shot
DmeCameraParams_t cameraParams( pAnimationSetName, vec3_origin, QAngle( 0, 180, 0 ) );
cameraParams.origin.x = pStudioHdr->hull_max.x + 20;
cameraParams.origin.z = Lerp( 0.95f, pStudioHdr->hull_min.z, pStudioHdr->hull_max.z );
cameraParams.fov = 75.0f;
CDmeCamera* pCamera = session.CreateCamera( cameraParams );
pShot->SetCamera( pCamera );
// Create a game model for the studio hdr
CDmeGameModel *pGameModel = session.CreateEditorGameModel( pStudioHdr, vec3_origin, Quaternion( 0, 0, 0, 1 ) );
// Create a scene for the shot
CDmeDag *pScene = session.FindOrCreateScene( pShot, pAnimationSetName );
pScene->AddChild( pGameModel );
// Create a sound clip
CDmeGameSound *pGameSound;
CDmeSoundClip *pSoundClip = CreateSoundClip( pMovie, pAnimationSetName, info.m_GameSound, pStudioHdr, &pGameSound );
pShot->SetDuration( pSoundClip->GetDuration() );
pMovie->SetDuration( pSoundClip->GetDuration() );
// Create an animation set
CDmeAnimationSet *pAnimationSet = CreateAnimationSet( pMovie, pShot, pGameModel, pAnimationSetName, 0, false );
// Extract phonemes
if ( pSoundClip )
{
CExtractInfo extractInfo;
extractInfo.m_pClip = pSoundClip;
extractInfo.m_pSound = pGameSound;
extractInfo.m_sHintText = info.m_Text;
extractInfo.m_bUseSentence = sfmGenInfo.m_bUsePhonemesInWavs;
ExtractDesc_t extractDesc;
extractDesc.m_nExtractType = EXTRACT_WIPE_CLIP;
extractDesc.m_pMovie = pMovie;
extractDesc.m_pShot = pShot;
extractDesc.m_pSet = pAnimationSet;
extractDesc.m_flSampleRateHz = sfmGenInfo.m_flSampleRateHz;
extractDesc.m_flSampleFilterSize = sfmGenInfo.m_flSampleFilterSize;
extractDesc.m_WorkList.AddToTail( extractInfo );
BuildFacialControlList( pShot, pAnimationSet, extractDesc.m_ControlList );
sfm_phonemeextractor->Extract( SPEECH_API_LIPSINC, extractDesc, sfmGenInfo.m_bWritePhonemesInWavs );
CExtractInfo &results = extractDesc.m_WorkList[ 0 ];
CDmElement *pExtractionSettings = pGameSound->FindOrAddPhonemeExtractionSettings();
pExtractionSettings->SetValue< float >( "duration", results.m_flDuration );
// Store off phonemes
if ( !pExtractionSettings->HasAttribute( "results" ) )
{
pExtractionSettings->AddAttribute( "results", AT_ELEMENT_ARRAY );
}
CDmrElementArray< CDmElement > resultsArray( pExtractionSettings, "results" );
resultsArray.RemoveAll();
for ( int i = 0; i < results.m_ApplyTags.Count(); ++i )
{
CBasePhonemeTag *tag = results.m_ApplyTags[ i ];
CDmElement *tagElement = CreateElement< CDmElement >( ConvertPhoneme( tag->GetPhonemeCode() ), pGameSound->GetFileId() );
tagElement->SetValue< float >( "start", tag->GetStartTime() );
tagElement->SetValue< float >( "end", tag->GetEndTime() );
resultsArray.AddToTail( tagElement );
}
if ( pExportFacPath )
{
char pFACFileName[MAX_PATH];
Q_ComposeFileName( pExportFacPath, info.m_DMXFileName, pFACFileName, sizeof(pFACFileName) );
Q_SetExtension( pFACFileName, ".dmx", sizeof(pFACFileName) );
ExportFacialAnimation( pFACFileName, pMovie, pShot, pAnimationSet );
}
}
SaveSFMFile( session.Root(), pOutputDirectory, info.m_DMXFileName );
session.Shutdown();
}
