void CHL2MP_Player::FlyJetpack(void)
{
if (!IsDead())
{
SetGroundEntity(NULL);
Vector up;
AngleVectors(GetLocalAngles(), NULL, NULL, &up);
ApplyAbsVelocityImpulse(up * 15);
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CBaseHelicopter::FlyTouch( CBaseEntity *pOther )
{
// bounce if we hit something solid
if ( pOther->GetSolid() == SOLID_BSP)
{
trace_t tr = CBaseEntity::GetTouchTrace( );
// UNDONE, do a real bounce
ApplyAbsVelocityImpulse( tr.plane.normal * (GetAbsVelocity().Length() + 200) );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : flInterval -
// &m_LastMoveTarget -
// eMoveType -
//-----------------------------------------------------------------------------
void CNPC_Ichthyosaur::DoMovement( float flInterval, const Vector &MoveTarget, int eMoveType )
{
// dvs: something is setting this bit, causing us to stop moving and get stuck that way
Forget( bits_MEMORY_TURNING );
Vector Steer, SteerAvoid, SteerRel;
Vector forward, right, up;
//Get our orientation vectors.
GetVectors( &forward, &right, &up);
if ( ( GetActivity() == ACT_MELEE_ATTACK1 ) && ( GetEnemy() != NULL ) )
{
SteerSeek( Steer, GetEnemy()->GetAbsOrigin() );
}
else
{
//If we are approaching our goal, use an arrival steering mechanism.
if ( eMoveType == ICH_MOVETYPE_ARRIVE )
{
SteerArrive( Steer, MoveTarget );
}
else
{
//Otherwise use a seek steering mechanism.
SteerSeek( Steer, MoveTarget );
}
}
#if FEELER_COLLISION
Vector f, u, l, r, d;
float probeLength = GetAbsVelocity().Length();
if ( probeLength < 150 )
probeLength = 150;
if ( probeLength > 500 )
probeLength = 500;
f = DoProbe( GetLocalOrigin() + (probeLength * forward) );
r = DoProbe( GetLocalOrigin() + (probeLength/3 * (forward+right)) );
l = DoProbe( GetLocalOrigin() + (probeLength/3 * (forward-right)) );
u = DoProbe( GetLocalOrigin() + (probeLength/3 * (forward+up)) );
d = DoProbe( GetLocalOrigin() + (probeLength/3 * (forward-up)) );
SteerAvoid = f+r+l+u+d;
//NDebugOverlay::Line( GetLocalOrigin(), GetLocalOrigin()+SteerAvoid, 255, 255, 0, false, 0.1f );
if ( SteerAvoid.LengthSqr() )
{
Steer = (SteerAvoid*0.5f);
}
m_vecVelocity = m_vecVelocity + (Steer*0.5f);
VectorNormalize( m_vecVelocity );
SteerRel.x = forward.Dot( m_vecVelocity );
SteerRel.y = right.Dot( m_vecVelocity );
SteerRel.z = up.Dot( m_vecVelocity );
m_vecVelocity *= m_flGroundSpeed;
#else
//See if we need to avoid any obstacles.
if ( SteerAvoidObstacles( SteerAvoid, GetAbsVelocity(), forward, right, up ) )
{
//Take the avoidance vector
Steer = SteerAvoid;
}
//Clamp our ideal steering vector to within our physical limitations.
ClampSteer( Steer, SteerRel, forward, right, up );
ApplyAbsVelocityImpulse( Steer * flInterval );
#endif
Vector vecNewVelocity = GetAbsVelocity();
float flLength = vecNewVelocity.Length();
//Clamp our final speed
if ( flLength > m_flGroundSpeed )
{
vecNewVelocity *= ( m_flGroundSpeed / flLength );
flLength = m_flGroundSpeed;
}
Vector workVelocity = vecNewVelocity;
AddSwimNoise( &workVelocity );
// Pose the fish properly
SetPoses( SteerRel, flLength );
//Drag our victim before moving
if ( m_pVictim != NULL )
{
DragVictim( (workVelocity*flInterval).Length() );
}
//Move along the current velocity vector
if ( WalkMove( workVelocity * flInterval, MASK_NPCSOLID ) == false )
{
//Attempt a half-step
if ( WalkMove( (workVelocity*0.5f) * flInterval, MASK_NPCSOLID) == false )
{
//Restart the velocity
//VectorNormalize( m_vecVelocity );
vecNewVelocity *= 0.5f;
}
else
{
//Cut our velocity in half
vecNewVelocity *= 0.5f;
}
}
SetAbsVelocity( vecNewVelocity );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void CBaseHelicopter::Flight( void )
{
if( GetFlags() & FL_ONGROUND )
{
//This would be really bad.
SetGroundEntity( NULL );
}
// Generic speed up
if (m_flGoalSpeed < GetMaxSpeed())
{
m_flGoalSpeed += GetAcceleration();
}
//NDebugOverlay::Line(GetAbsOrigin(), m_vecDesiredPosition, 0,0,255, true, 0.1);
// tilt model 5 degrees (why?! sjb)
QAngle vecAdj = QAngle( 5.0, 0, 0 );
// estimate where I'll be facing in one seconds
Vector forward, right, up;
AngleVectors( GetLocalAngles() + GetLocalAngularVelocity() * 2 + vecAdj, &forward, &right, &up );
// Vector vecEst1 = GetLocalOrigin() + GetAbsVelocity() + up * m_flForce - Vector( 0, 0, 384 );
// float flSide = DotProduct( m_vecDesiredPosition - vecEst1, right );
QAngle angVel = GetLocalAngularVelocity();
float flSide = DotProduct( m_vecDesiredFaceDir, right );
if (flSide < 0)
{
if (angVel.y < 60)
{
angVel.y += 8;
}
}
else
{
if (angVel.y > -60)
{
angVel.y -= 8;
}
}
angVel.y *= ( 0.98 ); // why?! (sjb)
// estimate where I'll be in two seconds
AngleVectors( GetLocalAngles() + angVel * 1 + vecAdj, NULL, NULL, &up );
Vector vecEst = GetAbsOrigin() + GetAbsVelocity() * 2.0 + up * m_flForce * 20 - Vector( 0, 0, 384 * 2 );
// add immediate force
AngleVectors( GetLocalAngles() + vecAdj, &forward, &right, &up );
Vector vecImpulse( 0, 0, 0 );
vecImpulse.x += up.x * m_flForce;
vecImpulse.y += up.y * m_flForce;
vecImpulse.z += up.z * m_flForce;
// add gravity
vecImpulse.z -= 38.4; // 32ft/sec
ApplyAbsVelocityImpulse( vecImpulse );
float flSpeed = GetAbsVelocity().Length();
float flDir = DotProduct( Vector( forward.x, forward.y, 0 ), Vector( GetAbsVelocity().x, GetAbsVelocity().y, 0 ) );
if (flDir < 0)
{
flSpeed = -flSpeed;
}
float flDist = DotProduct( GetDesiredPosition() - vecEst, forward );
// float flSlip = DotProduct( GetAbsVelocity(), right );
float flSlip = -DotProduct( GetDesiredPosition() - vecEst, right );
// fly sideways
if (flSlip > 0)
{
if (GetLocalAngles().z > -30 && angVel.z > -15)
angVel.z -= 4;
else
angVel.z += 2;
}
else
{
if (GetLocalAngles().z < 30 && angVel.z < 15)
angVel.z += 4;
else
angVel.z -= 2;
}
// These functions contain code Ken wrote that used to be right here as part of the flight model,
// but we want different helicopter vehicles to have different drag characteristics, so I made
// them virtual functions (sjb)
ApplySidewaysDrag( right );
ApplyGeneralDrag();
// apply power to stay correct height
// FIXME: these need to be per class variables
#define MAX_FORCE 80
#define FORCE_POSDELTA 12
#define FORCE_NEGDELTA 8
if (m_flForce < MAX_FORCE && vecEst.z < GetDesiredPosition().z)
{
m_flForce += FORCE_POSDELTA;
}
else if (m_flForce > 30)
{
if (vecEst.z > GetDesiredPosition().z)
m_flForce -= FORCE_NEGDELTA;
}
// pitch forward or back to get to target
//-----------------------------------------
// Pitch is reversed since Half-Life! (sjb)
//-----------------------------------------
if (flDist > 0 && flSpeed < m_flGoalSpeed /* && flSpeed < flDist */ && GetLocalAngles().x + angVel.x < 40)
{
// ALERT( at_console, "F " );
// lean forward
angVel.x += 12.0;
}
else if (flDist < 0 && flSpeed > -50 && GetLocalAngles().x + angVel.x > -20)
{
// ALERT( at_console, "B " );
// lean backward
angVel.x -= 12.0;
}
else if (GetLocalAngles().x + angVel.x < 0)
{
// ALERT( at_console, "f " );
angVel.x += 4.0;
}
else if (GetLocalAngles().x + angVel.x > 0)
{
// ALERT( at_console, "b " );
angVel.x -= 4.0;
}
SetLocalAngularVelocity( angVel );
// ALERT( at_console, "%.0f %.0f : %.0f %.0f : %.0f %.0f : %.0f\n", GetAbsOrigin().x, GetAbsVelocity().x, flDist, flSpeed, GetLocalAngles().x, m_vecAngVelocity.x, m_flForce );
// ALERT( at_console, "%.0f %.0f : %.0f %0.f : %.0f\n", GetAbsOrigin().z, GetAbsVelocity().z, vecEst.z, m_vecDesiredPosition.z, m_flForce );
}
//------------------------------------------------------------------------------
// Purpose : Move toward targetmap
// Input :
// Output :
//------------------------------------------------------------------------------
void CGrenadeHomer::AimThink( void )
{
// Blow up the missile if we have an explicit detonate time that
// has been reached
if (m_flDetonateTime != 0 &&
gpGlobals->curtime > m_flDetonateTime)
{
Detonate();
return;
}
PlayFlySound();
Vector vTargetPos = vec3_origin;
Vector vTargetDir;
float flCurHomingStrength = 0;
// ------------------------------------------------
// If I'm homing
// ------------------------------------------------
if (m_hTarget != NULL)
{
vTargetPos = m_hTarget->EyePosition();
vTargetDir = vTargetPos - GetAbsOrigin();
VectorNormalize(vTargetDir);
// --------------------------------------------------
// If my target is far away do some primitive
// obstacle avoidance
// --------------------------------------------------
if ((vTargetPos - GetAbsOrigin()).Length() > 200)
{
Vector vTravelDir = GetAbsVelocity();
VectorNormalize(vTravelDir);
vTravelDir *= 50;
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + vTravelDir, MASK_SHOT, m_hTarget, COLLISION_GROUP_NONE, &tr );
if (tr.fraction != 1.0)
{
// Head off in normal
float dotPr = DotProduct(vTravelDir,tr.plane.normal);
Vector vBounce = -dotPr * tr.plane.normal;
vBounce.z = 0;
VectorNormalize(vBounce);
vTargetDir += vBounce;
VectorNormalize(vTargetDir);
// DEBUG TOOL
//NDebugOverlay::Line(GetOrigin(), GetOrigin()+vTravelDir, 255,0,0, true, 20);
//NDebugOverlay::Line(GetOrigin(), GetOrigin()+(12*tr.plane.normal), 0,0,255, true, 20);
//NDebugOverlay::Line(GetOrigin(), GetOrigin()+(vTargetDir), 0,255,0, true, 20);
}
}
float flTargetSpeed = GetAbsVelocity().Length();
float flHomingRampUpStartTime = m_flHomingLaunchTime + m_flHomingDelay;
float flHomingSustainStartTime = flHomingRampUpStartTime + m_flHomingRampUp;
float flHomingRampDownStartTime = flHomingSustainStartTime + m_flHomingDuration;
float flHomingEndHomingTime = flHomingRampDownStartTime + m_flHomingRampDown;
// ---------
// Delay
// ---------
if (gpGlobals->curtime < flHomingRampUpStartTime)
{
flCurHomingStrength = 0;
flTargetSpeed = 0;
}
// ----------
// Ramp Up
// ----------
else if (gpGlobals->curtime < flHomingSustainStartTime)
{
float flAge = gpGlobals->curtime - flHomingRampUpStartTime;
flCurHomingStrength = m_flHomingStrength * (flAge/m_flHomingRampUp);
flTargetSpeed = flCurHomingStrength * m_flHomingSpeed;
}
// ----------
// Sustain
// ----------
else if (gpGlobals->curtime < flHomingRampDownStartTime)
{
flCurHomingStrength = m_flHomingStrength;
flTargetSpeed = m_flHomingSpeed;
}
// -----------
// Ramp Down
// -----------
else if (gpGlobals->curtime < flHomingEndHomingTime)
{
float flAge = gpGlobals->curtime - flHomingRampDownStartTime;
flCurHomingStrength = m_flHomingStrength * (1-(flAge/m_flHomingRampDown));
flTargetSpeed = m_flHomingSpeed;
}
// ---------------
// Set Homing
// ---------------
if (flCurHomingStrength > 0)
{
// -------------
// Smoke trail.
// -------------
if (m_nRocketTrailType == HOMER_SMOKE_TRAIL_ON_HOMING)
{
UpdateRocketTrail(flCurHomingStrength);
}
// Extract speed and direction
Vector vCurDir = GetAbsVelocity();
float flCurSpeed = VectorNormalize(vCurDir);
flTargetSpeed = MAX(flTargetSpeed, flCurSpeed);
// Add in homing direction
Vector vecNewVelocity = GetAbsVelocity();
float flTimeToUse = gpGlobals->frametime;
while (flTimeToUse > 0)
{
vecNewVelocity = (flCurHomingStrength * vTargetDir) + ((1 - flCurHomingStrength) * vCurDir);
flTimeToUse = -0.1;
}
VectorNormalize(vecNewVelocity);
vecNewVelocity *= flTargetSpeed;
SetAbsVelocity( vecNewVelocity );
}
}
// ----------------------------------------------------------------------------------------
// Add time-coherent noise to the current velocity
// ----------------------------------------------------------------------------------------
Vector vecImpulse( 0, 0, 0 );
if (m_flSpinMagnitude > 0)
{
vecImpulse.x += m_flSpinMagnitude*sin(m_flSpinSpeed * gpGlobals->curtime + m_flSpinOffset);
vecImpulse.y += m_flSpinMagnitude*cos(m_flSpinSpeed * gpGlobals->curtime + m_flSpinOffset);
vecImpulse.z -= m_flSpinMagnitude*cos(m_flSpinSpeed * gpGlobals->curtime + m_flSpinOffset);
}
// Add in gravity
vecImpulse.z -= GetGravity() * GetCurrentGravity() * gpGlobals->frametime;
ApplyAbsVelocityImpulse( vecImpulse );
QAngle angles;
VectorAngles( GetAbsVelocity(), angles );
SetLocalAngles( angles );
#if 0 // BUBBLE
if( gpGlobals->curtime > m_flNextWarnTime )
{
// Make a bubble of warning sound in front of me.
const float WARN_INTERVAL = 0.25f;
float flSpeed = GetAbsVelocity().Length();
Vector vecWarnLocation;
// warn a little bit ahead of us, please.
vecWarnLocation = GetAbsOrigin() + GetAbsVelocity() * 0.75;
// Make a bubble of warning ahead of the missile.
CSoundEnt::InsertSound ( SOUND_DANGER, vecWarnLocation, flSpeed * WARN_INTERVAL, 0.5 );
#if 0
Vector vecRight, vecForward;
AngleVectors( GetAbsAngles(), &vecForward, &vecRight, NULL );
NDebugOverlay::Line( vecWarnLocation, vecWarnLocation + vecForward * flSpeed * WARN_INTERVAL * 0.5, 255,255,0, true, 10);
NDebugOverlay::Line( vecWarnLocation, vecWarnLocation - vecForward * flSpeed * WARN_INTERVAL * 0.5, 255,255,0, true, 10);
NDebugOverlay::Line( vecWarnLocation, vecWarnLocation + vecRight * flSpeed * WARN_INTERVAL * 0.5, 255,255,0, true, 10);
NDebugOverlay::Line( vecWarnLocation, vecWarnLocation - vecRight * flSpeed * WARN_INTERVAL * 0.5, 255,255,0, true, 10);
#endif
m_flNextWarnTime = gpGlobals->curtime + WARN_INTERVAL;
}
#endif // BUBBLE
SetNextThink( gpGlobals->curtime + 0.1f );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFastZombie::StartTask( const Task_t *pTask )
{
switch( pTask->iTask )
{
case TASK_FASTZOMBIE_VERIFY_ATTACK:
// Simply ensure that the zombie still has a valid melee attack
if( HasCondition( COND_CAN_MELEE_ATTACK1 ) )
{
TaskComplete();
}
else
{
TaskFail("");
}
break;
case TASK_FASTZOMBIE_JUMP_BACK:
{
SetActivity( ACT_IDLE );
RemoveFlag( FL_ONGROUND );
BeginAttackJump();
Vector forward;
AngleVectors( GetLocalAngles(), &forward );
//
// Take him off ground so engine doesn't instantly reset FL_ONGROUND.
//
UTIL_SetOrigin( this, GetLocalOrigin() + Vector( 0 , 0 , 1 ));
ApplyAbsVelocityImpulse( forward * -200 + Vector( 0, 0, 200 ) );
}
break;
case TASK_FASTZOMBIE_UNSTICK_JUMP:
{
RemoveFlag( FL_ONGROUND );
// Call begin attack jump. A little bit later if we fail to pathfind, we check
// this value to see if we just jumped. If so, we assume we've jumped
// to someplace that's not pathing friendly, and so must jump again to get out.
BeginAttackJump();
//
// Take him off ground so engine doesn't instantly reset FL_ONGROUND.
//
UTIL_SetOrigin( this, GetLocalOrigin() + Vector( 0 , 0 , 1 ));
CBaseEntity *pEnemy = GetEnemy();
Vector vecJumpDir;
if ( GetActivity() == ACT_CLIMB_UP || GetActivity() == ACT_CLIMB_DOWN )
{
// Jump off the pipe backwards!
Vector forward;
GetVectors( &forward, NULL, NULL );
ApplyAbsVelocityImpulse( forward * -200 );
}
else if( pEnemy )
{
vecJumpDir = pEnemy->GetLocalOrigin() - GetLocalOrigin();
VectorNormalize( vecJumpDir );
vecJumpDir.z = 0;
ApplyAbsVelocityImpulse( vecJumpDir * 300 + Vector( 0, 0, 200 ) );
}
else
{
Msg("UNHANDLED CASE! Stuck Fast Zombie with no enemy!\n");
}
}
break;
case TASK_WAIT_FOR_MOVEMENT:
// If we're waiting for movement, that means that pathfinding succeeded, and
// we're about to be moving. So we aren't stuck. So clear this flag.
m_fJustJumped = false;
BaseClass::StartTask( pTask );
break;
case TASK_FACE_ENEMY:
{
// We don't use the base class implementation of this, because GetTurnActivity
// stomps our landing scrabble animations (sjb)
Vector flEnemyLKP = GetEnemyLKP();
GetMotor()->SetIdealYawToTarget( flEnemyLKP );
}
break;
case TASK_FASTZOMBIE_LAND_RECOVER:
{
// Set the ideal yaw
Vector flEnemyLKP = GetEnemyLKP();
GetMotor()->SetIdealYawToTarget( flEnemyLKP );
// figure out which way to turn.
float flDeltaYaw = GetMotor()->DeltaIdealYaw();
if( flDeltaYaw < 0 )
{
SetIdealActivity( (Activity)ACT_FASTZOMBIE_LAND_RIGHT );
}
else
{
SetIdealActivity( (Activity)ACT_FASTZOMBIE_LAND_LEFT );
}
TaskComplete();
}
break;
case TASK_RANGE_ATTACK1:
// Make melee attacks impossible until we land!
m_flNextMeleeAttack = gpGlobals->curtime + 60;
SetTouch( LeapAttackTouch );
break;
case TASK_FASTZOMBIE_DO_ATTACK:
SetActivity( (Activity)ACT_FASTZOMBIE_LEAP_SOAR );
break;
default:
BaseClass::StartTask( pTask );
break;
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_CombineDropship::Flight( void )
{
// Only run pose params in some flight states
bool bRunPoseParams = ( m_iLandState == LANDING_NO ||
m_iLandState == LANDING_LEVEL_OUT ||
m_iLandState == LANDING_LIFTOFF ||
m_iLandState == LANDING_SWOOPING );
if ( bRunPoseParams )
{
if( GetFlags() & FL_ONGROUND )
{
//This would be really bad.
RemoveFlag( FL_ONGROUND );
}
// NDebugOverlay::Line(GetLocalOrigin(), GetDesiredPosition(), 0,0,255, true, 0.1);
Vector deltaPos = GetDesiredPosition() - GetLocalOrigin();
// calc desired acceleration
float dt = 1.0f;
Vector accel;
float accelRate = DROPSHIP_ACCEL_RATE;
float maxSpeed = m_flMaxSpeed;
if ( m_lifeState == LIFE_DYING )
{
accelRate *= 5.0;
maxSpeed *= 5.0;
}
float flDist = min( GetAbsVelocity().Length() + accelRate, maxSpeed );
// Only decelerate to our goal if we're going to hit it
if ( deltaPos.Length() > flDist * dt )
{
float scale = flDist * dt / deltaPos.Length();
deltaPos = deltaPos * scale;
}
// If we're swooping, floor it
if ( m_iLandState == LANDING_SWOOPING )
{
VectorNormalize( deltaPos );
deltaPos *= maxSpeed;
}
// calc goal linear accel to hit deltaPos in dt time.
accel.x = 2.0 * (deltaPos.x - GetAbsVelocity().x * dt) / (dt * dt);
accel.y = 2.0 * (deltaPos.y - GetAbsVelocity().y * dt) / (dt * dt);
accel.z = 2.0 * (deltaPos.z - GetAbsVelocity().z * dt + 0.5 * 384 * dt * dt) / (dt * dt);
//NDebugOverlay::Line(GetLocalOrigin(), GetLocalOrigin() + deltaPos, 255,0,0, true, 0.1);
//NDebugOverlay::Line(GetLocalOrigin(), GetLocalOrigin() + accel, 0,255,0, true, 0.1);
// don't fall faster than 0.2G or climb faster than 2G
if ( m_iLandState != LANDING_SWOOPING )
{
accel.z = clamp( accel.z, 384 * 0.2, 384 * 2.0 );
}
Vector forward, right, up;
GetVectors( &forward, &right, &up );
Vector goalUp = accel;
VectorNormalize( goalUp );
// calc goal orientation to hit linear accel forces
float goalPitch = RAD2DEG( asin( DotProduct( forward, goalUp ) ) );
float goalYaw = UTIL_VecToYaw( m_vecDesiredFaceDir );
float goalRoll = RAD2DEG( asin( DotProduct( right, goalUp ) ) );
// clamp goal orientations
goalPitch = clamp( goalPitch, -45, 60 );
goalRoll = clamp( goalRoll, -45, 45 );
// calc angular accel needed to hit goal pitch in dt time.
dt = 0.6;
QAngle goalAngAccel;
goalAngAccel.x = 2.0 * (AngleDiff( goalPitch, AngleNormalize( GetLocalAngles().x ) ) - GetLocalAngularVelocity().x * dt) / (dt * dt);
goalAngAccel.y = 2.0 * (AngleDiff( goalYaw, AngleNormalize( GetLocalAngles().y ) ) - GetLocalAngularVelocity().y * dt) / (dt * dt);
goalAngAccel.z = 2.0 * (AngleDiff( goalRoll, AngleNormalize( GetLocalAngles().z ) ) - GetLocalAngularVelocity().z * dt) / (dt * dt);
goalAngAccel.x = clamp( goalAngAccel.x, -300, 300 );
//goalAngAccel.y = clamp( goalAngAccel.y, -60, 60 );
goalAngAccel.y = clamp( goalAngAccel.y, -120, 120 );
goalAngAccel.z = clamp( goalAngAccel.z, -300, 300 );
// limit angular accel changes to simulate mechanical response times
dt = 0.1;
QAngle angAccelAccel;
angAccelAccel.x = (goalAngAccel.x - m_vecAngAcceleration.x) / dt;
angAccelAccel.y = (goalAngAccel.y - m_vecAngAcceleration.y) / dt;
angAccelAccel.z = (goalAngAccel.z - m_vecAngAcceleration.z) / dt;
angAccelAccel.x = clamp( angAccelAccel.x, -1000, 1000 );
angAccelAccel.y = clamp( angAccelAccel.y, -1000, 1000 );
angAccelAccel.z = clamp( angAccelAccel.z, -1000, 1000 );
m_vecAngAcceleration += angAccelAccel * 0.1;
// Msg( "pitch %6.1f (%6.1f:%6.1f) ", goalPitch, GetLocalAngles().x, m_vecAngVelocity.x );
// Msg( "roll %6.1f (%6.1f:%6.1f) : ", goalRoll, GetLocalAngles().z, m_vecAngVelocity.z );
// Msg( "%6.1f %6.1f %6.1f : ", goalAngAccel.x, goalAngAccel.y, goalAngAccel.z );
// Msg( "%6.0f %6.0f %6.0f\n", angAccelAccel.x, angAccelAccel.y, angAccelAccel.z );
ApplySidewaysDrag( right );
ApplyGeneralDrag();
QAngle angVel = GetLocalAngularVelocity();
angVel += m_vecAngAcceleration * 0.1;
//angVel.y = clamp( angVel.y, -60, 60 );
//angVel.y = clamp( angVel.y, -120, 120 );
angVel.y = clamp( angVel.y, -120, 120 );
SetLocalAngularVelocity( angVel );
m_flForce = m_flForce * 0.8 + (accel.z + fabs( accel.x ) * 0.1 + fabs( accel.y ) * 0.1) * 0.1 * 0.2;
Vector vecImpulse = m_flForce * up;
if ( m_lifeState == LIFE_DYING )
{
vecImpulse.z = -38.4; // 64ft/sec
}
else
{
vecImpulse.z -= 38.4; // 32ft/sec
}
// Find our acceleration direction
Vector vecAccelDir = vecImpulse;
VectorNormalize( vecAccelDir );
// Find our current velocity
Vector vecVelDir = GetAbsVelocity();
VectorNormalize( vecVelDir );
// Level out our plane of movement
vecAccelDir.z = 0.0f;
vecVelDir.z = 0.0f;
forward.z = 0.0f;
right.z = 0.0f;
// Find out how "fast" we're moving in relation to facing and acceleration
float speed = m_flForce * DotProduct( vecVelDir, vecAccelDir );// * DotProduct( forward, vecVelDir );
// Use the correct pose params
char *sBodyAccel;
char *sBodySway;
if ( m_hContainer || m_iLandState == LANDING_SWOOPING )
{
sBodyAccel = "cargo_body_accel";
sBodySway = "cargo_body_sway";
SetPoseParameter( "body_accel", 0 );
SetPoseParameter( "body_sway", 0 );
}
else
{
sBodyAccel = "body_accel";
sBodySway = "body_sway";
SetPoseParameter( "cargo_body_accel", 0 );
SetPoseParameter( "cargo_body_sway", 0 );
}
// Apply the acceleration blend to the fins
float finAccelBlend = SimpleSplineRemapVal( speed, -60, 60, -1, 1 );
float curFinAccel = GetPoseParameter( sBodyAccel );
curFinAccel = UTIL_Approach( finAccelBlend, curFinAccel, 0.5f );
SetPoseParameter( sBodyAccel, curFinAccel );
speed = m_flForce * DotProduct( vecVelDir, right );
// Apply the spin sway to the fins
float finSwayBlend = SimpleSplineRemapVal( speed, -60, 60, -1, 1 );
float curFinSway = GetPoseParameter( sBodySway );
curFinSway = UTIL_Approach( finSwayBlend, curFinSway, 0.5f );
SetPoseParameter( sBodySway, curFinSway );
// Add in our velocity pulse for this frame
ApplyAbsVelocityImpulse( vecImpulse );
//Msg("FinAccel: %f, Finsway: %f\n", curFinAccel, curFinSway );
}
else
{
SetPoseParameter( "body_accel", 0 );
SetPoseParameter( "body_sway", 0 );
SetPoseParameter( "cargo_body_accel", 0 );
SetPoseParameter( "cargo_body_sway", 0 );
}
}
int CSDKPlayer::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
// set damage type sustained
m_bitsDamageType |= info.GetDamageType();
if ( !CBaseCombatCharacter::OnTakeDamage_Alive( info ) )
return 0;
CBaseEntity * attacker = info.GetAttacker();
if ( !attacker )
return 0;
Vector vecDir = vec3_origin;
if ( info.GetInflictor() )
{
vecDir = info.GetInflictor()->WorldSpaceCenter() - Vector ( 0, 0, 10 ) - WorldSpaceCenter();
VectorNormalize( vecDir );
}
if ( info.GetInflictor() && (GetMoveType() == MOVETYPE_WALK) &&
( !attacker->IsSolidFlagSet(FSOLID_TRIGGER)) )
{
Vector force = vecDir;// * -DamageForce( WorldAlignSize(), info.GetBaseDamage() );
if ( force.z > 250.0f )
{
force.z = 250.0f;
}
ApplyAbsVelocityImpulse( force );
}
// Burnt
if ( info.GetDamageType() & DMG_BURN )
{
EmitSound( "Player.BurnPain" );
}
// fire global game event
IGameEvent * event = gameeventmanager->CreateEvent( "player_hurt" );
if ( event )
{
event->SetInt("userid", GetUserID() );
event->SetInt("health", MAX(0, m_iHealth) );
event->SetInt("priority", 5 ); // HLTV event priority, not transmitted
if ( attacker->IsPlayer() )
{
CBasePlayer *player = ToBasePlayer( attacker );
event->SetInt("attacker", player->GetUserID() ); // hurt by other player
}
else
{
event->SetInt("attacker", 0 ); // hurt by "world"
}
gameeventmanager->FireEvent( event );
}
// Insert a combat sound so that nearby NPCs hear battle
if ( attacker->IsNPC() )
{
CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 512, 0.5, this );
}
return 1;
}
