//----------------------------------------------------------------------------- // 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 ); }