//-----------------------------------------------------------------------------
// 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();
}
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;
}
void CNPC_Infected::SetupGlobalModelData()
{
if ( gm_nMoveXPoseParam != -1 )
return;
gm_nMoveXPoseParam = LookupPoseParameter( "move_x" );
gm_nMoveYPoseParam = LookupPoseParameter( "move_y" );
gm_nLeanYawPoseParam = LookupPoseParameter( "lean_yaw" );
gm_nLeanPitchPoseParam = LookupPoseParameter( "lean_pitch" );
}
//-----------------------------------------------------------------------------
// 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 );
}
//-----------------------------------------------------------------------------
// 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 );
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::Spawn()
{
Precache();
Wake( false );
SetModel("models/props_combine/combine_mine01.mdl");
SetSolid( SOLID_VPHYSICS );
m_hSprite.Set( NULL );
m_takedamage = DAMAGE_EVENTS_ONLY;
// Find my feet!
m_iHookN = LookupPoseParameter( "blendnorth" );
m_iHookE = LookupPoseParameter( "blendeast" );
m_iHookS = LookupPoseParameter( "blendsouth" );
m_iAllHooks = LookupPoseParameter( "blendstates" );
m_flHookPositions = 0;
SetHealth( 100 );
m_bBounce = true;
SetSequence( SelectWeightedSequence( ACT_IDLE ) );
OpenHooks( true );
m_bHeldByPhysgun = false;
m_iFlipAttempts = 0;
if( !GetParent() )
{
// Create vphysics now if I'm not being carried.
CreateVPhysics();
}
m_flTimeGrabbed = FLT_MAX;
if( m_bDisarmed )
{
SetMineState( MINE_STATE_DORMANT );
}
else
{
SetMineState( MINE_STATE_DEPLOY );
}
}
//-----------------------------------------------------------------------------
// 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;
}
//-----------------------------------------------------------------------------
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();
}
//-----------------------------------------------------------------------------
// Purpose: cache the build pos pose param
//-----------------------------------------------------------------------------
CStudioHdr *C_TFWeaponBuilder::OnNewModel( void )
{
CStudioHdr *hdr = BaseClass::OnNewModel();
m_iValidBuildPoseParam = LookupPoseParameter( "valid_build_pos" );
return hdr;
}
//=========================================================
//=========================================================
bool CAnimating::HasPoseParameter( int iSequence, const char *szName )
{
int iParameter = LookupPoseParameter( szName );
if (iParameter == -1)
{
return false;
}
return HasPoseParameter( iSequence, iParameter );
}
CStudioHdr *C_FirstpersonBody::OnNewModel()
{
CStudioHdr *pRet = BaseClass::OnNewModel();
m_iBoneNeck = LookupBone( "ValveBiped.Bip01_Neck1" );
m_iBoneArmL = LookupBone( "ValveBiped.Bip01_L_UpperArm" );
m_iBoneArmR = LookupBone( "ValveBiped.Bip01_R_UpperArm" );
m_iPoseParam_MoveYaw = LookupPoseParameter( "move_yaw" );
return pRet;
}
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 );
}
/**
* Set up attachment and pose param indices.
* We can't do this in the constructor or Spawn() because the data isn't
* there yet.
*/
void C_CHostage::Initialize( )
{
m_eyeAttachment = LookupAttachment( "eyes" );
m_chestAttachment = LookupAttachment( "chest" );
m_headYawPoseParam = LookupPoseParameter( "head_yaw" );
GetPoseParameterRange( m_headYawPoseParam, m_headYawMin, m_headYawMax );
m_headPitchPoseParam = LookupPoseParameter( "head_pitch" );
GetPoseParameterRange( m_headPitchPoseParam, m_headPitchMin, m_headPitchMax );
m_bodyYawPoseParam = LookupPoseParameter( "body_yaw" );
GetPoseParameterRange( m_bodyYawPoseParam, m_bodyYawMin, m_bodyYawMax );
Vector pos;
QAngle angles;
if (!GetAttachment( m_eyeAttachment, pos, angles ))
{
m_vecViewOffset = Vector( 0, 0, 50.0f );
}
else
{
m_vecViewOffset = pos - GetAbsOrigin();
}
if (!GetAttachment( m_chestAttachment, pos, angles ))
{
m_lookAt = Vector( 0, 0, 0 );
}
else
{
Vector forward;
AngleVectors( angles, &forward );
m_lookAt = EyePosition() + 100.0f * forward;
}
}
//-----------------------------------------------------------------------------
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;
}
//Player is notified when view perspective is changed
void C_DHL_Player::PerspectiveChanged( int iType )
{
switch ( iType )
{
case PCHANGE_TOTHIRDPERSON:
{
//Reset aim yaw pose param
int upper_body_yaw = LookupPoseParameter( "aim_yaw" );
if ( upper_body_yaw >= 0 )
SetPoseParameter( upper_body_yaw, 0.0f );
AddBaseAnimatingInterpolatedVars();
return;
break;
}
case PCHANGE_TOFIRSTPERSON:
{
RemoveBaseAnimatingInterpolatedVars();
return;
break;
}
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::Spawn()
{
Precache();
Wake( false );
SetModel("models/props_combine/combine_mine01.mdl");
SetSolid( SOLID_VPHYSICS );
m_hSprite.Set( NULL );
m_takedamage = DAMAGE_EVENTS_ONLY;
// Find my feet!
m_iHookN = LookupPoseParameter( "blendnorth" );
m_iHookE = LookupPoseParameter( "blendeast" );
m_iHookS = LookupPoseParameter( "blendsouth" );
m_iAllHooks = LookupPoseParameter( "blendstates" );
m_flHookPositions = 0;
SetHealth( 100 );
m_bBounce = true;
SetSequence( SelectWeightedSequence( ACT_IDLE ) );
OpenHooks( true );
m_bHeldByPhysgun = false;
m_iFlipAttempts = 0;
if( !GetParent() )
{
// Create vphysics now if I'm not being carried.
CreateVPhysics();
}
m_flTimeGrabbed = FLT_MAX;
if( m_bDisarmed )
{
SetMineState( MINE_STATE_DORMANT );
}
else
{
SetMineState( MINE_STATE_DEPLOY );
}
// default to a different skin for cavern turrets (unless explicitly overridden)
if ( m_iModification == MINE_MODIFICATION_CAVERN )
{
// look for this value in the first datamap
// loop through the data description list, restoring each data desc block
datamap_t *dmap = GetDataDescMap();
bool bFoundSkin = false;
// search through all the readable fields in the data description, looking for a match
for ( int i = 0; i < dmap->dataNumFields; ++i )
{
if ( dmap->dataDesc[i].flags & (FTYPEDESC_OUTPUT | FTYPEDESC_KEY) )
{
if ( !Q_stricmp(dmap->dataDesc[i].externalName, "Skin") )
{
bFoundSkin = true;
break;
}
}
}
if (!bFoundSkin)
{
// select a random skin for the mine. Actually, we'll cycle through the available skins
// using a static variable to provide better distribution. The static isn't saved but
// really it's only cosmetic.
static unsigned int nextSkin = MINE_CITIZEN_SKIN_MIN;
m_nSkin = nextSkin;
// increment the skin for next time
nextSkin = (nextSkin >= MINE_CITIZEN_SKIN_MAX) ? MINE_CITIZEN_SKIN_MIN : nextSkin + 1;
}
// pretend like the player set me down.
m_bPlacedByPlayer = true;
}
}
//-----------------------------------------------------------------------------
// Methods related to spawn
//-----------------------------------------------------------------------------
void CFourWheelVehiclePhysics::InitializePoseParameters()
{
m_poseParameters[VEH_FL_WHEEL_HEIGHT] = LookupPoseParameter( "vehicle_wheel_fl_height" );
m_poseParameters[VEH_FR_WHEEL_HEIGHT] = LookupPoseParameter( "vehicle_wheel_fr_height" );
m_poseParameters[VEH_RL_WHEEL_HEIGHT] = LookupPoseParameter( "vehicle_wheel_rl_height" );
m_poseParameters[VEH_RR_WHEEL_HEIGHT] = LookupPoseParameter( "vehicle_wheel_rr_height" );
m_poseParameters[VEH_FL_WHEEL_SPIN] = LookupPoseParameter( "vehicle_wheel_fl_spin" );
m_poseParameters[VEH_FR_WHEEL_SPIN] = LookupPoseParameter( "vehicle_wheel_fr_spin" );
m_poseParameters[VEH_RL_WHEEL_SPIN] = LookupPoseParameter( "vehicle_wheel_rl_spin" );
m_poseParameters[VEH_RR_WHEEL_SPIN] = LookupPoseParameter( "vehicle_wheel_rr_spin" );
m_poseParameters[VEH_STEER] = LookupPoseParameter( "vehicle_steer" );
m_poseParameters[VEH_ACTION] = LookupPoseParameter( "vehicle_action" );
m_poseParameters[VEH_SPEEDO] = LookupPoseParameter( "vehicle_guage" );
// move the wheels to a neutral position
SetPoseParameter( m_poseParameters[VEH_SPEEDO], 0 );
SetPoseParameter( m_poseParameters[VEH_STEER], 0 );
SetPoseParameter( m_poseParameters[VEH_FL_WHEEL_HEIGHT], 0 );
SetPoseParameter( m_poseParameters[VEH_FR_WHEEL_HEIGHT], 0 );
SetPoseParameter( m_poseParameters[VEH_RL_WHEEL_HEIGHT], 0 );
SetPoseParameter( m_poseParameters[VEH_RR_WHEEL_HEIGHT], 0 );
m_pOuter->InvalidateBoneCache();
}
float StudioModel::GetPoseParameter( char const *szName )
{
return GetPoseParameter( LookupPoseParameter( szName ) );
}
float StudioModel::SetPoseParameter( char const *szName, float flValue )
{
return SetPoseParameter( LookupPoseParameter( szName ), flValue );
}
void C_StriderRagdoll::CreateStriderRagdoll( void )
{
// First, initialize all our data. If we have the player's entity on our client,
// then we can make ourselves start out exactly where the player is.
C_QUA_Strider *pStrider = dynamic_cast< C_QUA_Strider* >( m_hStrider.Get());
if ( pStrider)
{
// move my current model instance to the ragdoll's so decals are preserved.
pStrider->SnatchModelInstance( this );
VarMapping_t *varMap = GetVarMapping();
// Copy all the interpolated vars from the player entity.
// The entity uses the interpolated history to get bone velocity.
/*bool bRemotePlayer = (pPlayer != C_BasePlayer::GetLocalPlayer());
if ( bRemotePlayer )
{*/
Interp_Copy( varMap, this, pStrider, pStrider->C_BaseAnimating::GetVarMapping() );
SetAbsAngles( pStrider->GetRenderAngles() );
GetRotationInterpolator().Reset();
m_flAnimTime = pStrider->m_flAnimTime;
SetSequence( pStrider->GetSequence() );
m_flPlaybackRate = pStrider->GetPlaybackRate();
SetPoseParameter(LookupPoseParameter("body_height"),200.0f);
/*}
else
{*/
// This is the local player, so set them in a default
// pose and slam their velocity, angles and origin
// SetAbsOrigin( m_vecRagdollOrigin );
//
// SetAbsAngles( pPlayer->GetRenderAngles() );
// SetAbsVelocity( m_vecRagdollVelocity );
// int iSeq = pPlayer->GetSequence();
// if ( iSeq == -1 )
// {
// Assert( false ); // missing walk_lower?
// iSeq = 0;
// }
//
// SetSequence( iSeq ); // walk_lower, basic pose
// SetCycle( 0.0 );
// Interp_Reset( varMap );
//}
}
else
{
// overwrite network origin so later interpolation will
// use this position
SetNetworkOrigin( m_vecRagdollOrigin );
SetAbsOrigin( m_vecRagdollOrigin );
SetAbsVelocity( m_vecRagdollVelocity );
SetSequence(LookupSequence("idle01"));
SetPoseParameter(LookupPoseParameter("body_height"),m_fAltura);
Interp_Reset( GetVarMapping() );
}
SetModelIndex( m_nModelIndex );
//engine->Con_NPrintf(27,"Le volvemos a poner de altura: %f",m_fAltura);
SetPoseParameter(LookupPoseParameter("body_height"),200.0f);
// Make us a ragdoll..
m_nRenderFX = kRenderFxRagdoll;
BecomeRagdollOnClient( /*false*/ ); //FixMe No? xd
}
void C_ASW_Simple_Drone::UpdatePoseParams()
{
VPROF_BUDGET( "C_ASW_Simple_Drone::UpdatePoseParams", VPROF_BUDGETGROUP_ASW_CLIENT );
// update pose params based on velocity and our angles
// calculate the angle difference between our facing and our velocity
Vector v;
EstimateAbsVelocity(v);
float travel_yaw = anglemod(UTIL_VecToYaw(v));
float current_yaw = anglemod( GetLocalAngles().y );
// Draw a green triangle on the ground for the travel yaw
if (cl_asw_drone_travel_yaw.GetBool())
{
float flBaseSize = 10;
float flHeight = 80;
Vector vBasePos = GetAbsOrigin() + Vector( 0, 0, 5 );
QAngle angles( 0, 0, 0 );
Vector vForward, vRight, vUp;
angles[YAW] = travel_yaw;
AngleVectors( angles, &vForward, &vRight, &vUp );
debugoverlay->AddTriangleOverlay( vBasePos+vRight*flBaseSize/2, vBasePos-vRight*flBaseSize/2, vBasePos+vForward*flHeight, 0, 255, 0, 255, false, 0.01 );
}
// calculate our fraction of full anim velocity
float speed_fraction = 0;
float ground_speed = GetRunSpeed();
if (ground_speed > 0)
speed_fraction = clamp<float>(
(v.Length()) / ground_speed,
0.0f, 1.0f);
speed_fraction = 1.0f - speed_fraction;
// smooth out the travel yaw to prevent sudden changes in move_yaw pose parameter
if (m_flCurrentTravelYaw == -1)
m_flCurrentTravelYaw = travel_yaw;
else
{
float travel_diff = AngleDiff(m_flCurrentTravelYaw, travel_yaw);
if (travel_diff < 0)
travel_diff = -travel_diff;
travel_diff = clamp<float>(travel_diff, 32.0f, 256.0f); // alter the yaw by this amount - i.e. faster if the angle is bigger, but clamped
if (speed_fraction > 0.75f) // change the angle even quicker if we're moving very slowly
{
travel_diff *= (2.0f + ((speed_fraction - 0.75f) * 8.0f));
}
if (speed_fraction < 1.0f) // don't bother adjusting the yaw if we're standing still
m_flCurrentTravelYaw = AI_ClampYaw( travel_diff * cl_asw_drone_travel_yaw_rate.GetFloat(), m_flCurrentTravelYaw, travel_yaw, gpGlobals->frametime );
else
m_flCurrentTravelYaw = travel_yaw; // if we're standing still, immediately change
//Msg("travel=%.1f current_travel=%.1f current=%.1f t=%f\n",
//travel_yaw, m_flCurrentTravelYaw, current_yaw, gpGlobals->curtime);
travel_yaw = m_flCurrentTravelYaw;
}
// set the move_yaw pose parameter
float diff = AngleDiff(travel_yaw, current_yaw);
// Draw a green triangle on the ground for the move yaw
if (cl_asw_drone_travel_yaw.GetBool())
{
float flBaseSize = 10;
float flHeight = 80;
Vector vBasePos = GetAbsOrigin() + Vector( 0, 0, 5 );
QAngle angles( 0, 0, 0 );
Vector vForward, vRight, vUp;
angles[YAW] = travel_yaw;
AngleVectors( angles, &vForward, &vRight, &vUp );
debugoverlay->AddTriangleOverlay( vBasePos+vRight*flBaseSize/2, vBasePos-vRight*flBaseSize/2, vBasePos+vForward*flHeight, 0, 0, 255, 255, false, 0.01 );
angles[YAW] = diff;
AngleVectors( angles, &vForward, &vRight, &vUp );
debugoverlay->AddTriangleOverlay( vBasePos+vRight*flBaseSize/2, vBasePos-vRight*flBaseSize/2, vBasePos+vForward*flHeight, 255, 0, 0, 255, false, 0.01 );
}
diff = clamp<float>(diff, -180.0f, 180.0f);
int pose_index = LookupPoseParameter( "move_yaw" );
if (pose_index >= 0)
{
SetPoseParameter(pose_index, diff);
}
// smooth out our speed fraction to prevent sudden changes to idle_move pose parameter
//Msg("sf=%f cts=%f gs=%f vl=%f\n", speed_fraction, m_flCurrentTravelSpeed,
//ground_speed, v.Length());
if (m_flCurrentTravelSpeed == -1)
{
m_flCurrentTravelSpeed = speed_fraction;
}
else
{
if (m_flCurrentTravelSpeed < speed_fraction)
{
m_flCurrentTravelSpeed = clamp<float>(
m_flCurrentTravelSpeed + gpGlobals->frametime,
0.0f, speed_fraction);
}
else
{
m_flCurrentTravelSpeed = clamp<float>(
m_flCurrentTravelSpeed - gpGlobals->frametime * 3.0f,
speed_fraction, 1.0f);
}
speed_fraction = m_flCurrentTravelSpeed;
}
// set the idle_move pose parameter
pose_index = LookupPoseParameter( "idle_move" );
if (pose_index >= 0)
{
SetPoseParameter(pose_index, 100.0f * speed_fraction);
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets the new owner of the point, plays the appropriate sound and shows the right model
//-----------------------------------------------------------------------------
void CTeamControlPoint::InternalSetOwner( int iCapTeam, bool bMakeSound, int iNumCappers, int *pCappingPlayers )
{
Assert( iCapTeam >= 0 && iCapTeam < GetNumberOfTeams() );
int iOldTeam = m_iTeam;
m_iTeam = iCapTeam;
ChangeTeam( iCapTeam );
if ( bMakeSound )
{
CBroadcastRecipientFilter filter;
EmitSound( filter, entindex(), STRING( m_TeamData[m_iTeam].iszCapSound ) );
}
// Update visuals
SetModel( STRING(m_TeamData[m_iTeam].iszModel) );
SetBodygroup( 0, m_iTeam );
m_nSkin = ( m_iTeam == TEAM_UNASSIGNED ) ? 2 : (m_iTeam - 2);
ResetSequence( LookupSequence("idle") );
// We add 1 to the index because we consider the default "no points capped" as 0.
TeamplayGameRules()->SetLastCapPointChanged( m_iPointIndex+1 );
// Determine the pose parameters for each team
for ( int i = 0; i < m_TeamData.Count(); i++ )
{
// Skip spectator
if ( i == TEAM_SPECTATOR )
continue;
if ( GetModelPtr() && GetModelPtr()->SequencesAvailable() )
{
m_TeamData[i].iTeamPoseParam = LookupPoseParameter( UTIL_VarArgs( "cappoint_%d_percentage", i ) );
}
else
{
m_TeamData[i].iTeamPoseParam = -1;
}
}
UpdateCapPercentage();
if ( m_iTeam == TEAM_UNASSIGNED )
{
m_OnCapReset.FireOutput( this, this );
}
else
{
// Remap team to get first game team = 1
switch ( m_iTeam - FIRST_GAME_TEAM+1 )
{
case 1:
m_OnCapTeam1.FireOutput( this, this );
break;
case 2:
m_OnCapTeam2.FireOutput( this, this );
break;
default:
Assert(0);
break;
}
}
// If we're playing a sound, this is a true cap by players.
if ( bMakeSound )
{
if ( iOldTeam > LAST_SHARED_TEAM && iOldTeam != m_iTeam )
{
// Make the members of our old team say something
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBaseMultiplayerPlayer *pPlayer = ToBaseMultiplayerPlayer( UTIL_PlayerByIndex( i ) );
if ( !pPlayer )
continue;
if ( pPlayer->GetTeamNumber() == iOldTeam )
{
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_LOST_CONTROL_POINT );
}
}
}
for( int i = 0; i < iNumCappers; i++ )
{
int playerIndex = pCappingPlayers[i];
Assert( playerIndex > 0 && playerIndex <= gpGlobals->maxClients );
PlayerCapped( ToBaseMultiplayerPlayer(UTIL_PlayerByIndex( playerIndex )) );
}
// Remap team to get first game team = 1
switch ( m_iTeam - FIRST_GAME_TEAM+1 )
{
case 1:
m_OnOwnerChangedToTeam1.FireOutput( this, this );
break;
case 2:
m_OnOwnerChangedToTeam2.FireOutput( this, this );
break;
}
if ( m_iTeam != TEAM_UNASSIGNED && iNumCappers )
{
SendCapString( m_iTeam, iNumCappers, pCappingPlayers );
}
}
// Have control point master check the win conditions now!
CBaseEntity *pEnt = gEntList.FindEntityByClassname( NULL, GetControlPointMasterName() );
while( pEnt )
{
CTeamControlPointMaster *pMaster = dynamic_cast<CTeamControlPointMaster *>( pEnt );
if ( pMaster->IsActive() )
{
pMaster->CheckWinConditions();
}
pEnt = gEntList.FindEntityByClassname( pEnt, GetControlPointMasterName() );
}
}
//=========================================================
//=========================================================
float CAnimating::SetPoseParameter( CStudioHdr *pStudioHdr, const char *szName, float flValue )
{
int poseParam = LookupPoseParameter( pStudioHdr, szName );
//AssertMsg2(poseParam >= 0, "SetPoseParameter called with invalid argument %s by %s", szName, GetDebugName());
return SetPoseParameter( pStudioHdr, poseParam, flValue );
}
