//------------------------------------------------
// Spawn
//------------------------------------------------
void CPropAPC::Spawn( void )
{
BaseClass::Spawn();
SetBlocksLOS( true );
m_iHealth = m_iMaxHealth = sk_apc_health.GetFloat();
SetCycle( 0 );
m_iMachineGunBurstLeft = MACHINE_GUN_BURST_SIZE;
m_iRocketSalvoLeft = ROCKET_SALVO_SIZE;
m_nRocketSide = 0;
m_lifeState = LIFE_ALIVE;
m_bInFiringCone = false;
m_flHandbrakeTime = gpGlobals->curtime + 0.1;
m_bInitialHandbrake = false;
// Reset the gun to a default pose.
SetPoseParameter( "vehicle_weapon_pitch", 0 );
SetPoseParameter( "vehicle_weapon_yaw", 90 );
CreateAPCLaserDot();
if ( IsXbox() )
{
AddFlag( FL_AIMTARGET );
}
}
//------------------------------------------------
// Spawn
//------------------------------------------------
void CPropAPC2::Spawn( void )
{
SetVehicleType( VEHICLE_TYPE_CAR_WHEELS );
BaseClass::Spawn();
SetBlocksLOS( true );
m_iHealth = m_iMaxHealth = 500;
m_iAmmoCount=30; // Balas seguidas que podemos disparar
m_iCannonCount=100; // Tanto por cien de cañon.
SetCycle( 0 );
m_iMachineGunBurstLeft = MACHINE_GUN_BURST_SIZE;
m_iRocketSalvoLeft = ROCKET_SALVO_SIZE;
m_fReloadTime=gpGlobals->curtime+0.5f;
m_fCannonCharge=gpGlobals->curtime+0.05f;
m_nRocketSide = 0;
m_lifeState = LIFE_ALIVE;
m_bInFiringCone = false;
m_flHandbrakeTime = gpGlobals->curtime + 0.1;
m_bInitialHandbrake = false;
// Reset the gun to a default pose.
SetPoseParameter( "vehicle_weapon_pitch", 0 );
SetPoseParameter( "vehicle_weapon_yaw", 90 );
AddSolidFlags( FSOLID_NOT_STANDABLE );
m_vOriginalSpawnOrigin = GetAbsOrigin();
m_vOriginalSpawnAngles = GetAbsAngles();
m_bSpawn=false;
CreateAPCLaserDot();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CFourWheelVehiclePhysics::VPhysicsUpdate( IPhysicsObject *pPhysics )
{
if ( r_vehicleDrawDebug.GetInt() )
{
DrawDebugGeometryOverlays();
}
// must be a wheel
if ( pPhysics == m_pOuter->VPhysicsGetObject() )
return true;
// This is here so we can make the pose parameters of the wheels
// reflect their current physics state
for ( int i = 0; i < m_wheelCount; i++ )
{
if ( pPhysics == m_pWheels[i] )
{
Vector tmp;
pPhysics->GetPosition( &m_wheelPosition[i], &m_wheelRotation[i] );
// transform the wheel into body space
VectorITransform( m_wheelPosition[i], m_pOuter->EntityToWorldTransform(), tmp );
SetPoseParameter( m_poseParameters[VEH_FL_WHEEL_HEIGHT + i], (m_wheelBaseHeight[i] - tmp.z) / m_wheelTotalHeight[i] );
SetPoseParameter( m_poseParameters[VEH_FL_WHEEL_SPIN + i], -m_wheelRotation[i].z );
return false;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSentrygun::SetModel( const char *pModel )
{
float flPoseParam0 = 0.0;
float flPoseParam1 = 0.0;
// Save pose parameters across model change
if ( m_iPitchPoseParameter >= 0 )
{
flPoseParam0 = GetPoseParameter( m_iPitchPoseParameter );
}
if ( m_iYawPoseParameter >= 0 )
{
flPoseParam1 = GetPoseParameter( m_iYawPoseParameter );
}
BaseClass::SetModel( pModel );
// Reset this after model change
UTIL_SetSize( this, SENTRYGUN_MINS, SENTRYGUN_MAXS );
SetSolid( SOLID_BBOX );
// Restore pose parameters
m_iPitchPoseParameter = LookupPoseParameter( "aim_pitch" );
m_iYawPoseParameter = LookupPoseParameter( "aim_yaw" );
SetPoseParameter( m_iPitchPoseParameter, flPoseParam0 );
SetPoseParameter( m_iYawPoseParameter, flPoseParam1 );
CreateBuildPoints();
ReattachChildren();
ResetSequenceInfo();
}
void CBaseTurret::Spawn()
{
Precache( );
SetNextThink( gpGlobals->curtime + 1 );
SetMoveType( MOVETYPE_FLY );
m_nSequence = 0;
m_flCycle = 0;
SetSolid( SOLID_SLIDEBOX );
m_takedamage = DAMAGE_YES;
AddFlag( FL_AIMTARGET );
m_iAmmoType = g_pGameRules->GetAmmoDef()->Index("SMG1");
AddFlag( FL_NPC );
if (( m_spawnflags & SF_NPC_TURRET_AUTOACTIVATE ) && !( m_spawnflags & SF_NPC_TURRET_STARTINACTIVE ))
{
m_iAutoStart = true;
}
ResetSequenceInfo( );
SetPoseParameter( TURRET_BC_YAW, 0 );
SetPoseParameter( TURRET_BC_PITCH, 0 );
// Activities
ADD_CUSTOM_ACTIVITY( CBaseTurret, ACT_TURRET_OPEN );
ADD_CUSTOM_ACTIVITY( CBaseTurret, ACT_TURRET_CLOSE );
ADD_CUSTOM_ACTIVITY( CBaseTurret, ACT_TURRET_CLOSED_IDLE );
ADD_CUSTOM_ACTIVITY( CBase`matTurret, ACT_TURRET_OPEN_IDLE );
ADD_CUSTOM_ACTIVITY( CBaseTurret, ACT_TURRET_FIRE );
ADD_CUSTOM_ACTIVITY( CBaseTurret, ACT_TURRET_RELOAD );
}
int CBaseTurret::MoveTurret(void)
{
bool bDidMove = false;
int iPose;
matrix3x4_t localToWorld;
GetAttachment( LookupAttachment( "eyes" ), localToWorld );
Vector vecGoalDir;
AngleVectors( m_vecGoalAngles, &vecGoalDir );
Vector vecGoalLocalDir;
VectorIRotate( vecGoalDir, localToWorld, vecGoalLocalDir );
QAngle vecGoalLocalAngles;
VectorAngles( vecGoalLocalDir, vecGoalLocalAngles );
float flDiff;
QAngle vecNewAngles;
// update pitch
flDiff = AngleNormalize( UTIL_ApproachAngle( vecGoalLocalAngles.x, 0.0, 0.1 * m_iBaseTurnRate ) );
iPose = LookupPoseParameter( TURRET_BC_PITCH );
SetPoseParameter( iPose, GetPoseParameter( iPose ) + flDiff / 1.5 );
if (fabs(flDiff) > 0.1)
{
bDidMove = true;
}
// update yaw, with acceleration
#if 0
float flDist = AngleNormalize( vecGoalLocalAngles.y );
float flNewDist;
float flNewTurnRate;
ChangeDistance( 0.1, flDist, 0.0, m_fTurnRate, m_iBaseTurnRate, m_iBaseTurnRate * 4, flNewDist, flNewTurnRate );
m_fTurnRate = flNewTurnRate;
flDiff = flDist - flNewDist;
#else
flDiff = AngleNormalize( UTIL_ApproachAngle( vecGoalLocalAngles.y, 0.0, 0.1 * m_iBaseTurnRate ) );
#endif
iPose = LookupPoseParameter( TURRET_BC_YAW );
SetPoseParameter( iPose, GetPoseParameter( iPose ) + flDiff / 1.5 );
if (fabs(flDiff) > 0.1)
{
bDidMove = true;
}
if (bDidMove)
{
// DevMsg( "(%.2f, %.2f)\n", AngleNormalize( vecGoalLocalAngles.x ), AngleNormalize( vecGoalLocalAngles.y ) );
}
return bDidMove;
}
//-----------------------------------------------------------------------------
// Purpose: Causes the turret to face its desired angles
//-----------------------------------------------------------------------------
bool CNPC_CeilingTurret::UpdateFacing( void )
{
bool bMoved = false;
matrix3x4_t localToWorld;
GetAttachment( LookupAttachment( "eyes" ), localToWorld );
Vector vecGoalDir;
AngleVectors( m_vecGoalAngles, &vecGoalDir );
Vector vecGoalLocalDir;
VectorIRotate( vecGoalDir, localToWorld, vecGoalLocalDir );
if ( g_debug_turret_ceiling.GetBool() )
{
Vector vecMuzzle, vecMuzzleDir;
QAngle vecMuzzleAng;
GetAttachment( "eyes", vecMuzzle, vecMuzzleAng );
AngleVectors( vecMuzzleAng, &vecMuzzleDir );
NDebugOverlay::Cross3D( vecMuzzle, -Vector(2,2,2), Vector(2,2,2), 255, 255, 0, false, 0.05 );
NDebugOverlay::Cross3D( vecMuzzle+(vecMuzzleDir*256), -Vector(2,2,2), Vector(2,2,2), 255, 255, 0, false, 0.05 );
NDebugOverlay::Line( vecMuzzle, vecMuzzle+(vecMuzzleDir*256), 255, 255, 0, false, 0.05 );
NDebugOverlay::Cross3D( vecMuzzle, -Vector(2,2,2), Vector(2,2,2), 255, 0, 0, false, 0.05 );
NDebugOverlay::Cross3D( vecMuzzle+(vecGoalDir*256), -Vector(2,2,2), Vector(2,2,2), 255, 0, 0, false, 0.05 );
NDebugOverlay::Line( vecMuzzle, vecMuzzle+(vecGoalDir*256), 255, 0, 0, false, 0.05 );
}
QAngle vecGoalLocalAngles;
VectorAngles( vecGoalLocalDir, vecGoalLocalAngles );
// Update pitch
float flDiff = AngleNormalize( UTIL_ApproachAngle( vecGoalLocalAngles.x, 0.0, 0.1f * MaxYawSpeed() ) );
SetPoseParameter( m_poseAim_Pitch, GetPoseParameter( m_poseAim_Pitch ) + ( flDiff / 1.5f ) );
if ( fabs( flDiff ) > 0.1f )
{
bMoved = true;
}
// Update yaw
flDiff = AngleNormalize( UTIL_ApproachAngle( vecGoalLocalAngles.y, 0.0, 0.1f * MaxYawSpeed() ) );
SetPoseParameter( m_poseAim_Yaw, GetPoseParameter( m_poseAim_Yaw ) + ( flDiff / 1.5f ) );
if ( fabs( flDiff ) > 0.1f )
{
bMoved = true;
}
InvalidateBoneCache();
return bMoved;
}
bool CNPC_Infected::OverrideMoveFacing( const AILocalMoveGoal_t &move, float flInterval )
{
// required movement direction
float flMoveYaw = UTIL_VecToYaw( move.dir );
// FIXME: move this up to navigator so that path goals can ignore these overrides.
Vector dir;
float flInfluence = GetFacingDirection( dir );
dir = move.facing * (1 - flInfluence) + dir * flInfluence;
VectorNormalize( dir );
// ideal facing direction
float idealYaw = UTIL_AngleMod( UTIL_VecToYaw( dir ) );
// FIXME: facing has important max velocity issues
GetMotor()->SetIdealYawAndUpdate( idealYaw );
// find movement direction to compensate for not being turned far enough
float flDiff = UTIL_AngleDiff( flMoveYaw, GetLocalAngles().y );
// Setup the 9-way blend parameters based on our speed and direction.
Vector2D vCurMovePose( 0, 0 );
vCurMovePose.x = cos( DEG2RAD( flDiff ) ) * 1.0f; //flPlaybackRate;
vCurMovePose.y = -sin( DEG2RAD( flDiff ) ) * 1.0f; //flPlaybackRate;
SetPoseParameter( gm_nMoveXPoseParam, vCurMovePose.x );
SetPoseParameter( gm_nMoveYPoseParam, vCurMovePose.y );
// ==== Update Lean pose parameters
if ( gm_nLeanYawPoseParam >= 0 )
{
float targetLean = GetPoseParameter( gm_nMoveYPoseParam ) * 30.0f;
float curLean = GetPoseParameter( gm_nLeanYawPoseParam );
if( curLean < targetLean )
curLean += MIN(fabs(targetLean-curLean), GetAnimTimeInterval()*12.0f); //was 15.0f
else
curLean -= MIN(fabs(targetLean-curLean), GetAnimTimeInterval()*12.0f); //was 15.0f
SetPoseParameter( gm_nLeanYawPoseParam, curLean );
}
if( gm_nLeanPitchPoseParam >= 0 )
{
float targetLean = GetPoseParameter( gm_nMoveXPoseParam ) * -20.0f; //was -30.0f
float curLean = GetPoseParameter( gm_nLeanPitchPoseParam );
if( curLean < targetLean )
curLean += MIN(fabs(targetLean-curLean), GetAnimTimeInterval()*10.0f); //was 15.0f
else
curLean -= MIN(fabs(targetLean-curLean), GetAnimTimeInterval()*10.0f); //was 15.0f
SetPoseParameter( gm_nLeanPitchPoseParam, curLean );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Start building the object
//-----------------------------------------------------------------------------
bool CObjectSentrygun::StartBuilding( CBaseEntity *pBuilder )
{
SetModel( SENTRY_MODEL_LEVEL_1_UPGRADE );
CreateBuildPoints();
SetPoseParameter( m_iPitchPoseParameter, 0.0 );
SetPoseParameter( m_iYawPoseParameter, 0.0 );
return BaseClass::StartBuilding( pBuilder );
}
//-----------------------------------------------------------------------------
// Purpose: Spawn the entity
//-----------------------------------------------------------------------------
void CNPC_CeilingTurret::Spawn( void )
{
Precache();
SetModel( CEILING_TURRET_MODEL );
BaseClass::Spawn();
m_HackedGunPos = Vector( 0, 0, 12.75 );
SetViewOffset( EyeOffset( ACT_IDLE ) );
m_flFieldOfView = 0.0f;
m_takedamage = DAMAGE_YES;
m_iHealth = 1000;
m_bloodColor = BLOOD_COLOR_MECH;
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_STANDABLE );
SetHeight( CEILING_TURRET_RETRACT_HEIGHT );
AddFlag( FL_AIMTARGET );
AddEFlags( EFL_NO_DISSOLVE );
SetPoseParameter( m_poseAim_Yaw, 0 );
SetPoseParameter( m_poseAim_Pitch, 0 );
m_iAmmoType = GetAmmoDef()->Index( "AR2" );
//Create our eye sprite
m_pEyeGlow = CSprite::SpriteCreate( CEILING_TURRET_GLOW_SPRITE, GetLocalOrigin(), false );
m_pEyeGlow->SetTransparency( kRenderTransAdd, 255, 0, 0, 128, kRenderFxNoDissipation );
m_pEyeGlow->SetAttachment( this, 2 );
//Set our autostart state
m_bAutoStart = !!( m_spawnflags & SF_CEILING_TURRET_AUTOACTIVATE );
m_bEnabled = ( ( m_spawnflags & SF_CEILING_TURRET_STARTINACTIVE ) == false );
//Do we start active?
if ( m_bAutoStart && m_bEnabled )
{
SetThink( &CNPC_CeilingTurret::AutoSearchThink );
SetEyeState( TURRET_EYE_DORMANT );
}
else
{
SetEyeState( TURRET_EYE_DISABLED );
}
//Stagger our starting times
SetNextThink( gpGlobals->curtime + random->RandomFloat( 0.1f, 0.3f ) );
// Don't allow us to skip animation setup because our attachments are critical to us!
SetBoneCacheFlags( BCF_NO_ANIMATION_SKIP );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : void SyncPoseToAimAngles
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::SyncPoseToAimAngles ( void )
{
QAngle localAngles = TransformAnglesToLocalSpace( m_vecCurrentAngles.Get(), EntityToWorldTransform() );
// Update pitch
SetPoseParameter( m_iPosePitch, localAngles.x );
// Update yaw -- NOTE: This yaw movement is screwy for this model, we must invert the yaw delta and also skew an extra 90 deg to
// get the 'forward face' of the turret to match up with the look direction. If the model and it's pose parameters change, this will be wrong.
SetPoseParameter( m_iPoseYaw, AngleNormalize( -localAngles.y - 90 ) );
InvalidateBoneCache();
}
//-----------------------------------------------------------------------------
// Purpose: the entity
//-----------------------------------------------------------------------------
void CNPC_RocketTurret::Spawn( void )
{
Precache();
BaseClass::Spawn();
SetViewOffset( vec3_origin );
AddEFlags( EFL_NO_DISSOLVE );
SetModel( ROCKET_TURRET_MODEL_NAME );
SetSolid( SOLID_VPHYSICS );
m_iMuzzleAttachment = LookupAttachment ( "barrel" );
m_iLightAttachment = LookupAttachment ( "eye" );
m_iPosePitch = LookupPoseParameter( "aim_pitch" );
m_iPoseYaw = LookupPoseParameter( "aim_yaw" );
m_vecCurrentAngles = m_vecGoalAngles = GetAbsAngles();
CreateVPhysics();
//Set our autostart state
m_bEnabled = ( ( m_spawnflags & SF_ROCKET_TURRET_START_INACTIVE ) == false );
// Set Locked sprite
if ( m_bEnabled )
{
m_iLaserState = 1;
SetSequence(LookupSequence("idle"));
}
else
{
m_iLaserState = 0;
SetSequence(LookupSequence("inactive"));
}
SetCycle(1.0f);
UpdateSkin( ROCKET_SKIN_IDLE );
SetPoseParameter( "aim_pitch", 0 );
SetPoseParameter( "aim_yaw", -180 );
if ( m_bEnabled )
{
SetThink( &CNPC_RocketTurret::FollowThink );
}
SetNextThink( gpGlobals->curtime + ROCKET_TURRET_THINK_RATE );
}
/**
* Orient head and eyes towards m_lookAt.
*/
void C_HL2MP_Player::UpdateLookAt( void )
{
// head yaw
if (m_headYawPoseParam < 0 || m_headPitchPoseParam < 0)
return;
// orient eyes
m_viewtarget = m_vLookAtTarget;
// blinking
if (m_blinkTimer.IsElapsed())
{
m_blinktoggle = !m_blinktoggle;
m_blinkTimer.Start( RandomFloat( 1.5f, 4.0f ) );
}
// Figure out where we want to look in world space.
QAngle desiredAngles;
Vector to = m_vLookAtTarget - EyePosition();
VectorAngles( to, desiredAngles );
// Figure out where our body is facing in world space.
QAngle bodyAngles( 0, 0, 0 );
bodyAngles[YAW] = GetLocalAngles()[YAW];
float flBodyYawDiff = bodyAngles[YAW] - m_flLastBodyYaw;
m_flLastBodyYaw = bodyAngles[YAW];
// Set the head's yaw.
float desired = AngleNormalize( desiredAngles[YAW] - bodyAngles[YAW] );
desired = clamp( desired, m_headYawMin, m_headYawMax );
m_flCurrentHeadYaw = ApproachAngle( desired, m_flCurrentHeadYaw, 130 * gpGlobals->frametime );
// Counterrotate the head from the body rotation so it doesn't rotate past its target.
m_flCurrentHeadYaw = AngleNormalize( m_flCurrentHeadYaw - flBodyYawDiff );
desired = clamp( desired, m_headYawMin, m_headYawMax );
SetPoseParameter( m_headYawPoseParam, m_flCurrentHeadYaw );
// Set the head's yaw.
desired = AngleNormalize( desiredAngles[PITCH] );
desired = clamp( desired, m_headPitchMin, m_headPitchMax );
m_flCurrentHeadPitch = ApproachAngle( desired, m_flCurrentHeadPitch, 130 * gpGlobals->frametime );
m_flCurrentHeadPitch = AngleNormalize( m_flCurrentHeadPitch );
SetPoseParameter( m_headPitchPoseParam, m_flCurrentHeadPitch );
}
//-----------------------------------------------------------------------------
// Purpose: Causes the camera to face its desired angles
//-----------------------------------------------------------------------------
bool CNPC_CombineCamera::UpdateFacing()
{
bool bMoved = false;
matrix3x4_t localToWorld;
GetAttachment(LookupAttachment("eyes"), localToWorld);
Vector vecGoalDir;
AngleVectors(m_vecGoalAngles, &vecGoalDir );
Vector vecGoalLocalDir;
VectorIRotate(vecGoalDir, localToWorld, vecGoalLocalDir);
QAngle vecGoalLocalAngles;
VectorAngles(vecGoalLocalDir, vecGoalLocalAngles);
// Update pitch
float flDiff = AngleNormalize(UTIL_ApproachAngle( vecGoalLocalAngles.x, 0.0, 0.1f * MaxYawSpeed()));
int iPose = LookupPoseParameter(COMBINE_CAMERA_BC_PITCH);
SetPoseParameter(iPose, GetPoseParameter(iPose) + (flDiff / 1.5f));
if (fabs(flDiff) > 0.1f)
{
bMoved = true;
}
// Update yaw
flDiff = AngleNormalize(UTIL_ApproachAngle( vecGoalLocalAngles.y, 0.0, 0.1f * MaxYawSpeed()));
iPose = LookupPoseParameter(COMBINE_CAMERA_BC_YAW);
SetPoseParameter(iPose, GetPoseParameter(iPose) + (flDiff / 1.5f));
if (fabs(flDiff) > 0.1f)
{
bMoved = true;
}
if (bMoved && (m_flMoveSoundTime < gpGlobals->curtime))
{
EmitSound("NPC_CombineCamera.Move");
m_flMoveSoundTime = gpGlobals->curtime + CAMERA_MOVE_INTERVAL;
}
// You're going to make decisions based on this info. So bump the bone cache after you calculate everything
InvalidateBoneCache();
return bMoved;
}
//------------------------------------------------
// Spawn
//------------------------------------------------
void CPropCrane::Spawn( void )
{
Precache();
SetModel( STRING( GetModelName() ) );
SetCollisionGroup( COLLISION_GROUP_VEHICLE );
BaseClass::Spawn();
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_SOLID );
SetMoveType( MOVETYPE_NOCLIP );
m_takedamage = DAMAGE_EVENTS_ONLY;
m_flTurn = 0;
m_flExtension = 0;
m_flNextDangerSoundTime = 0;
m_flNextCreakSound = 0;
m_flNextDropAllowedTime = 0;
m_flSlowRaiseTime = 0;
m_bDropping = false;
m_bMagnetOn = false;
InitCraneSpeeds();
SetPoseParameter( "armextensionpose", m_flExtension );
CreateVPhysics();
SetNextThink( gpGlobals->curtime );
}
//------------------------------------------------
// Spawn
//------------------------------------------------
void CPropCannon::Spawn( void )
{
Precache();
SetModel( STRING( GetModelName() ) );
SetCollisionGroup( COLLISION_GROUP_VEHICLE );
BaseClass::Spawn();
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_SOLID );
SetMoveType( MOVETYPE_NOCLIP );
m_takedamage = DAMAGE_EVENTS_ONLY;
m_takedamage = DAMAGE_EVENTS_ONLY;
m_flTurn = 0;
m_flExtension = 0;
m_flFlyTime = 0.0f;
m_flNextAttackTime = gpGlobals->curtime;
InitCannonSpeeds();
SetPoseParameter( "armextensionpose", m_flExtension );
CreateVPhysics();
SetNextThink( gpGlobals->curtime );
}
// Blending Cycler think
void CBlendingCycler::Think( void )
{
SetNextThink( gpGlobals->curtime + 0.1f );
// Move
m_iCurrent += m_iBlendspeed;
if ( (m_iCurrent > m_iUpperBound) || (m_iCurrent < m_iLowerBound) )
m_iBlendspeed = m_iBlendspeed * -1;
// Set blend
SetPoseParameter( 0, m_iCurrent );
Msg( "Current Blend: %d\n", m_iCurrent );
if (IsSequenceFinished() && !SequenceLoops())
{
// ResetSequenceInfo();
// hack to avoid reloading model every frame
m_flAnimTime = gpGlobals->curtime;
m_flPlaybackRate = 1.0;
m_bSequenceFinished = false;
m_flLastEventCheck = 0;
m_flCycle = 0;
if (!m_animate)
{
m_flPlaybackRate = 0.0; // FIX: don't reset framerate
}
}
}
//-----------------------------------------------------------------------------
void C_CHostage::UpdateClientSideAnimation()
{
if (IsDormant())
{
return;
}
m_PlayerAnimState->Update( GetAbsAngles()[YAW], GetAbsAngles()[PITCH] );
// initialize pose parameters
char *setToZero[] =
{
"spine_yaw",
"head_roll"
};
CStudioHdr *pStudioHdr = GetModelPtr();
for ( int i=0; i < ARRAYSIZE( setToZero ); i++ )
{
int index = LookupPoseParameter( pStudioHdr, setToZero[i] );
if ( index >= 0 )
SetPoseParameter( pStudioHdr, index, 0 );
}
// orient head and eyes
LookAround();
UpdateLookAt( pStudioHdr );
BaseClass::UpdateClientSideAnimation();
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::CloseHooks()
{
if( !m_bLockSilently )
{
EmitSound( "NPC_CombineMine.CloseHooks" );
}
if( VPhysicsGetObject() )
{
// It's possible to not have a valid physics object here, since this function doubles as an initialization function.
PhysSetGameFlags( VPhysicsGetObject(), FVPHYSICS_CONSTRAINT_STATIC );
}
// Only lock silently the first time we call this.
m_bLockSilently = false;
SetPoseParameter( m_iAllHooks, 0 );
VPhysicsGetObject()->EnableMotion( false );
// Once I lock down, forget how many tries it took.
m_iFlipAttempts = 0;
#ifdef _XBOX
AddEffects( EF_NOSHADOW );
#endif
}
//-----------------------------------------------------------------------------
// Primary gun
//-----------------------------------------------------------------------------
void CPropAPC::AimPrimaryWeapon( const Vector &vecWorldTarget )
{
EntityMatrix parentMatrix;
parentMatrix.InitFromEntity( this, m_nMachineGunBaseAttachment );
Vector target = parentMatrix.WorldToLocal( vecWorldTarget );
float quadTarget = target.LengthSqr();
float quadTargetXY = target.x*target.x + target.y*target.y;
// Target is too close! Can't aim at it
if ( quadTarget > m_vecBarrelPos.LengthSqr() )
{
// We're trying to aim the offset barrel at an arbitrary point.
// To calculate this, I think of the target as being on a sphere with
// it's center at the origin of the gun.
// The rotation we need is the opposite of the rotation that moves the target
// along the surface of that sphere to intersect with the gun's shooting direction
// To calculate that rotation, we simply calculate the intersection of the ray
// coming out of the barrel with the target sphere (that's the new target position)
// and use atan2() to get angles
// angles from target pos to center
float targetToCenterYaw = atan2( target.y, target.x );
float centerToGunYaw = atan2( m_vecBarrelPos.y, sqrt( quadTarget - (m_vecBarrelPos.y*m_vecBarrelPos.y) ) );
float targetToCenterPitch = atan2( target.z, sqrt( quadTargetXY ) );
float centerToGunPitch = atan2( -m_vecBarrelPos.z, sqrt( quadTarget - (m_vecBarrelPos.z*m_vecBarrelPos.z) ) );
QAngle angles;
angles.Init( -RAD2DEG(targetToCenterPitch+centerToGunPitch), RAD2DEG( targetToCenterYaw + centerToGunYaw ), 0 );
SetPoseParameter( "vehicle_weapon_yaw", angles.y );
SetPoseParameter( "vehicle_weapon_pitch", angles.x );
StudioFrameAdvance();
float curPitch = GetPoseParameter( "vehicle_weapon_pitch" );
float curYaw = GetPoseParameter( "vehicle_weapon_yaw" );
m_bInFiringCone = (fabs(curPitch - angles.x) < 1e-3) && (fabs(curYaw - angles.y) < 1e-3);
}
else
{
m_bInFiringCone = false;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPlayer -
// *pMoveData -
//-----------------------------------------------------------------------------
void CPropCannon::RunCraneMovement( float flTime )
{
if ( m_flExtensionRate )
{
// Extend / Retract the crane
m_flExtension = clamp( m_flExtension + (m_flExtensionRate * 10 * flTime), 0, 2 );
SetPoseParameter( "armextensionpose", m_flExtension );
StudioFrameAdvance();
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::CaptiveThink()
{
SetNextThink( gpGlobals->curtime + 0.05 );
StudioFrameAdvance();
float phase = fabs( sin( gpGlobals->curtime * 4.0f ) );
phase *= BOUNCEBOMB_HOOK_RANGE;
SetPoseParameter( m_iAllHooks, phase );
return;
}
void C_SkeletonPlayer::UpdateClientSideAnimation()
{
int curSeq = GetSequence();
Vector vel = GetLocalVelocity();
//EstimateAbsVelocity( vel );
int goalSeq = curSeq;
if ( vel.LengthSqr() > 4 )
{
QAngle velAng;
VectorAngles( vel, velAng );
goalSeq = SelectWeightedSequence( ACT_RUN );
float speed = vel.Length2D();
float yaw = AngleNormalize( -(GetRenderAngles().y - velAng.y) );
float seqspeed = 150.0f;
float rate = speed / seqspeed;
SetPoseParameter( LookupPoseParameter( "move_x" ), cos( DEG2RAD( yaw ) ) * rate );
SetPoseParameter( LookupPoseParameter( "move_y" ), -sin( DEG2RAD( yaw ) ) * rate );
SetPlaybackRate( clamp( rate * 0.6f, 1, 1.5f ) );
}
else
goalSeq = SelectWeightedSequence( ACT_IDLE );
if ( curSeq != goalSeq )
{
ResetSequence( goalSeq );
}
//m_flAnimTime = gpGlobals->curtime;
//StudioFrameAdvance();
if ( GetCycle() >= 1.0f )
SetCycle( GetCycle() - 1.0f );
}
void CPropVehicleManhack::UpdateHead( void )
{
float yaw = GetPoseParameter( "head_yaw" );
float pitch = GetPoseParameter( "head_pitch" );
// If we should be watching our enemy, turn our head
CNPC_Manhack *pManhack=GetManhack();
if (pManhack != NULL)
{
Vector vehicleEyeOrigin;
QAngle vehicleEyeAngles;
GetAttachment( "vehicle_driver_eyes", vehicleEyeOrigin, vehicleEyeAngles );
// FIXME: cache this
Vector vBodyDir;
AngleVectors( vehicleEyeAngles, &vBodyDir );
Vector manhackDir = pManhack->GetAbsOrigin() - vehicleEyeOrigin;
VectorNormalize( manhackDir );
float angle = UTIL_VecToYaw( vBodyDir );
float angleDiff = UTIL_VecToYaw( manhackDir );
angleDiff = UTIL_AngleDiff( angleDiff, angle + yaw );
SetPoseParameter( "head_yaw", UTIL_Approach( yaw + angleDiff, yaw, 1 ) );
angle = UTIL_VecToPitch( vBodyDir );
angleDiff = UTIL_VecToPitch( manhackDir );
angleDiff = UTIL_AngleDiff( angleDiff, angle + pitch );
SetPoseParameter( "head_pitch", UTIL_Approach( pitch + angleDiff, pitch, 1 ) );
}
else
{
// Otherwise turn the head back to its normal position
SetPoseParameter( "head_yaw", UTIL_Approach( 0, yaw, 10 ) );
SetPoseParameter( "head_pitch", UTIL_Approach( 0, pitch, 10 ) );
}
}
void CBaseTurret::Initialize(void)
{
m_iOn = 0;
m_fBeserk = 0;
SetPoseParameter( TURRET_BC_YAW, 0 );
SetPoseParameter( TURRET_BC_PITCH, 0 );
if (m_iBaseTurnRate == 0) m_iBaseTurnRate = TURRET_TURNRATE;
if (m_flMaxWait == 0) m_flMaxWait = TURRET_MAXWAIT;
m_vecGoalAngles = GetAngles();
if (m_iAutoStart)
{
m_flLastSight = gpGlobals->curtime + m_flMaxWait;
SetThink(AutoSearchThink);
SetNextThink( gpGlobals->curtime + .1 );
}
else
SetThink(SUB_DoNothing);
}
//------------------------------------------------
// Spawn
//------------------------------------------------
void CASW_PropJeep::Spawn( void )
{
// Setup vehicle as a real-wheels car.
SetVehicleType( VEHICLE_TYPE_CAR_WHEELS );
BaseClass::Spawn();
m_flHandbrakeTime = gpGlobals->curtime + 0.1;
m_bInitialHandbrake = false;
m_flMinimumSpeedToEnterExit = LOCK_SPEED;
m_nBulletType = GetAmmoDef()->Index("GaussEnergy");
if ( m_bHasGun )
{
SetBodygroup( 1, true );
}
else
{
SetBodygroup( 1, false );
}
// Initialize pose parameters
SetPoseParameter( JEEP_GUN_YAW, 0 );
SetPoseParameter( JEEP_GUN_PITCH, 0 );
m_nSpinPos = 0;
SetPoseParameter( JEEP_GUN_SPIN, m_nSpinPos );
m_aimYaw = 0;
m_aimPitch = 0;
AddSolidFlags( FSOLID_NOT_STANDABLE );
CAmmoDef *pAmmoDef = GetAmmoDef();
m_nAmmoType = pAmmoDef->Index("GaussEnergy");
// normal HL2 vehicles don't feel nice in a network game
// so destroy ourselves and spawn the serverside component of our custom ASW client authorative vehicle system
}
//-----------------------------------------------------------------------------
// Purpose: Clear all pose parameters
//-----------------------------------------------------------------------------
void C_HL2MP_Player::InitializePoseParams( void )
{
m_headYawPoseParam = LookupPoseParameter( "head_yaw" );
GetPoseParameterRange( m_headYawPoseParam, m_headYawMin, m_headYawMax );
m_headPitchPoseParam = LookupPoseParameter( "head_pitch" );
GetPoseParameterRange( m_headPitchPoseParam, m_headPitchMin, m_headPitchMax );
CStudioHdr *hdr = GetModelPtr();
for ( int i = 0; i < hdr->GetNumPoseParameters() ; i++ )
{
SetPoseParameter( hdr, i, 0.0 );
}
}
//-----------------------------------------------------------------------------
bool C_LowViolenceHostageDeathModel::SetupLowViolenceModel( C_CHostage *pHostage )
{
const model_t *model = pHostage->GetModel();
const char *pModelName = modelinfo->GetModelName( model );
if ( InitializeAsClientEntity( pModelName, RENDER_GROUP_OPAQUE_ENTITY ) == false )
{
Release();
return false;
}
// Play the low-violence death anim
if ( LookupSequence( "death1" ) == -1 )
{
Release();
return false;
}
m_flFadeOutStart = gpGlobals->curtime + 5.0f;
SetNextClientThink( CLIENT_THINK_ALWAYS );
SetSequence( LookupSequence( "death1" ) );
ForceClientSideAnimationOn();
if ( pHostage && !pHostage->IsDormant() )
{
SetNetworkOrigin( pHostage->GetAbsOrigin() );
SetAbsOrigin( pHostage->GetAbsOrigin() );
SetAbsVelocity( pHostage->GetAbsVelocity() );
// move my current model instance to the ragdoll's so decals are preserved.
pHostage->SnatchModelInstance( this );
SetAbsAngles( pHostage->GetRenderAngles() );
SetNetworkAngles( pHostage->GetRenderAngles() );
CStudioHdr *pStudioHdr = GetModelPtr();
// update pose parameters
float poseParameter[MAXSTUDIOPOSEPARAM];
GetPoseParameters( pStudioHdr, poseParameter );
for ( int i=0; i<NumInterestingPoseParameters; ++i )
{
int poseParameterIndex = LookupPoseParameter( pStudioHdr, InterestingPoseParameters[i] );
SetPoseParameter( pStudioHdr, poseParameterIndex, poseParameter[poseParameterIndex] );
}
}
Interp_Reset( GetVarMapping() );
return true;
}
//------------------------------------------------
// Spawn
//------------------------------------------------
void CPropJeep::Spawn( void )
{
// Setup vehicle as a real-wheels car.
SetVehicleType( VEHICLE_TYPE_CAR_WHEELS );
BaseClass::Spawn();
m_flHandbrakeTime = gpGlobals->curtime + 0.1;
m_bInitialHandbrake = false;
m_VehiclePhysics.SetHasBrakePedal( false );
m_flMinimumSpeedToEnterExit = LOCK_SPEED;
m_nBulletType = GetAmmoDef()->Index("GaussEnergy");
if ( m_bHasGun )
{
SetBodygroup( 1, true );
}
else
{
SetBodygroup( 1, false );
}
// Initialize pose parameters
SetPoseParameter( JEEP_GUN_YAW, 0 );
SetPoseParameter( JEEP_GUN_PITCH, 0 );
m_nSpinPos = 0;
SetPoseParameter( JEEP_GUN_SPIN, m_nSpinPos );
m_aimYaw = 0;
m_aimPitch = 0;
AddSolidFlags( FSOLID_NOT_STANDABLE );
CAmmoDef *pAmmoDef = GetAmmoDef();
m_nAmmoType = pAmmoDef->Index("GaussEnergy");
}
void CASW_Dummy_Vehicle::SetNormalizedPoseParameter(int iParam, float fValue)
{
CStudioHdr *pStudioHdr = GetModelPtr();
if (!pStudioHdr)
return;
if (iParam < 0 || iParam >= pStudioHdr->GetNumPoseParameters())
return;
const mstudioposeparamdesc_t &Pose = pStudioHdr->pPoseParameter( iParam );
float diff = Pose.end - Pose.start;
SetPoseParameter(iParam, Pose.start + diff * fValue);
}
