//----------------------------------------------------------------------------- // 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: This used to have something to do with bees flying, but // now it only initializes moving furniture in scripted sequences //----------------------------------------------------------------------------- void CNPC_Furniture::Spawn( ) { Precache(); SetModel( STRING(GetModelName()) ); SetMoveType( MOVETYPE_STEP ); SetSolid( SOLID_BBOX ); // Our collision, if needed, will be done through bone followers AddSolidFlags( FSOLID_NOT_SOLID ); SetBloodColor( DONT_BLEED ); m_iHealth = TOO_MUCH_HEALTH_TO_DIE; //wow m_takedamage = DAMAGE_AIM; SetSequence( 0 ); SetCycle( 0 ); SetNavType( NAV_FLY ); AddFlag( FL_FLY ); CapabilitiesAdd( bits_CAP_MOVE_FLY | bits_CAP_TURN_HEAD | bits_CAP_ANIMATEDFACE ); AddEFlags( EFL_NO_MEGAPHYSCANNON_RAGDOLL ); // pev->nextthink += 1.0; // SetThink (WalkMonsterDelay); ResetSequenceInfo( ); SetCycle( 0 ); NPCInit(); // Furniture needs to block LOS SetBlocksLOS( true ); // Furniture just wastes CPU doing sensing code, since all they do is idle and play scripts GetSenses()->AddSensingFlags( SENSING_FLAGS_DONT_LOOK | SENSING_FLAGS_DONT_LISTEN ); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CPropJetski::Think(void) { BaseClass::Think(); // set handbrake after physics sim settles down if ( gpGlobals->curtime < m_flHandbrakeTime ) { SetNextThink( gpGlobals->curtime ); } else if ( !m_bInitialHandbrake ) // after initial timer expires, set the handbrake { m_bInitialHandbrake = true; m_VehiclePhysics.SetHandbrake( true ); m_VehiclePhysics.Think(); } // play enter animation if ( (m_bEnterAnimOn || m_bExitAnimOn) && !IsSequenceFinished() ) { StudioFrameAdvance(); } else if ( IsSequenceFinished() ) { if ( m_bExitAnimOn ) { CBasePlayer *pPlayer = UTIL_GetLocalPlayer(); if ( pPlayer ) { pPlayer->LeaveVehicle(); // now that sequence is finished, leave car Vector vecEyes; QAngle vecEyeAng; GetAttachment( "vehicle_driver_eyes", vecEyes, vecEyeAng ); vecEyeAng.x = 0; vecEyeAng.z = 0; pPlayer->SnapEyeAngles( vecEyeAng ); } m_bExitAnimOn = false; } int iSequence = SelectWeightedSequence( ACT_IDLE ); if ( iSequence > ACTIVITY_NOT_AVAILABLE ) { SetCycle(0); m_flAnimTime = gpGlobals->curtime; ResetSequence( iSequence ); ResetClientsideFrame(); } } }
bool C_BaseViewModel::Interpolate( float currentTime ) { CStudioHdr *pStudioHdr = GetModelPtr(); // Make sure we reset our animation information if we've switch sequences UpdateAnimationParity(); bool bret = BaseClass::Interpolate( currentTime ); // Hack to extrapolate cycle counter for view model float elapsed_time = currentTime - m_flAnimTime; C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); // Predicted viewmodels have fixed up interval if ( GetPredictable() || IsClientCreated() ) { Assert( pPlayer ); float curtime = pPlayer ? pPlayer->GetFinalPredictedTime() : gpGlobals->curtime; elapsed_time = curtime - m_flAnimTime; // Adjust for interpolated partial frame if ( !engine->IsPaused() ) { elapsed_time += ( gpGlobals->interpolation_amount * TICK_INTERVAL ); } } // Prediction errors? if ( elapsed_time < 0 ) { elapsed_time = 0; } float dt = elapsed_time * GetSequenceCycleRate( pStudioHdr, GetSequence() ) * GetPlaybackRate(); if ( dt >= 1.0f ) { if ( !IsSequenceLooping( GetSequence() ) ) { dt = 0.999f; } else { dt = fmod( dt, 1.0f ); } } SetCycle( dt ); return bret; }
void CPropGladosCore::Spawn( void ) { SetupVOList(); Precache(); KeyValue( "model", GLADOS_CORE_MODEL_NAME ); BaseClass::Spawn(); //Default to 'dropped' animation ResetSequence(LookupSequence("drop")); SetCycle( 1.0f ); DisableAutoFade(); m_iEyeballAttachment = LookupAttachment( "eyeball" ); SetContextThink( &CPropGladosCore::AnimateThink, gpGlobals->curtime + 0.1f, s_pAnimateThinkContext ); }
//------------------------------------------------------------------------------ // Purpose : //------------------------------------------------------------------------------ void CNPC_VehicleDriver::Spawn( void ) { Precache( ); BaseClass::Spawn(); CapabilitiesClear(); CapabilitiesAdd( bits_CAP_MOVE_GROUND ); CapabilitiesAdd( bits_CAP_MOVE_SHOOT ); SetModel( "models/roller_vehicledriver.mdl" ); SetHullType(HULL_LARGE); SetHullSizeNormal(); m_iMaxHealth = m_iHealth = 1; m_flFieldOfView = VIEW_FIELD_FULL; SetSolid( SOLID_BBOX ); AddSolidFlags( FSOLID_NOT_SOLID ); SetMoveType( MOVETYPE_NONE ); AddEffects( EF_NODRAW ); m_lifeState = LIFE_ALIVE; SetCycle( 0 ); ResetSequenceInfo(); AddFlag( FL_NPC ); m_flMaxSpeed = 0; m_flGoalSpeed = m_flInitialSpeed; m_vecDesiredVelocity = vec3_origin; m_vecPrevPoint = vec3_origin; m_vecPrevPrevPoint = vec3_origin; m_vecPostPoint = vec3_origin; m_vecPostPostPoint = vec3_origin; m_vecDesiredPosition = vec3_origin; m_flSteering = 45; m_flDistanceAlongSpline = 0.2; m_pCurrentWaypoint = m_pNextWaypoint = NULL; GetNavigator()->SetPathcornerPathfinding( false ); NPCInit(); m_takedamage = DAMAGE_NO; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CAntlionGrub::Spawn( void ) { Precache(); BaseClass::Spawn(); SetModel( ANTLIONGRUB_MODEL ); // FIXME: This is a big perf hit with the number of grubs we're using! - jdw CreateGlow(); SetSolid( SOLID_BBOX ); SetSolidFlags( FSOLID_TRIGGER ); SetMoveType( MOVETYPE_NONE ); SetCollisionGroup( COLLISION_GROUP_NONE ); AddEffects( EF_NOSHADOW ); CollisionProp()->UseTriggerBounds(true,1); SetTouch( &CAntlionGrub::GrubTouch ); SetHealth( 1 ); m_takedamage = DAMAGE_YES; // Stick to the nearest surface if ( HasSpawnFlags( SF_ANTLIONGRUB_NO_AUTO_PLACEMENT ) == false ) { AttachToSurface(); } // At this point, alter our bounds to make sure we're within them Vector vecMins, vecMaxs; RotateAABB( EntityToWorldTransform(), CollisionProp()->OBBMins(), CollisionProp()->OBBMaxs(), vecMins, vecMaxs ); UTIL_SetSize( this, vecMins, vecMaxs ); // Start our idle activity SetSequence( SelectWeightedSequence( ACT_IDLE ) ); SetCycle( random->RandomFloat( 0.0f, 1.0f ) ); ResetSequenceInfo(); m_State = GRUB_STATE_IDLE; // Reset m_flFlinchTime = 0.0f; m_flNextIdleSoundTime = gpGlobals->curtime + random->RandomFloat( 4.0f, 8.0f ); }
void CWreckage::Spawn( void ) { SetSolid( SOLID_NONE ); SetMoveType( MOVETYPE_NONE ); m_takedamage = 0; SetCycle( 0 ); SetNextThink( gpGlobals->curtime + 0.1f ); if (GetModelName() != NULL_STRING) { PrecacheModel( STRING( GetModelName() ) ); SetModel( STRING( GetModelName() ) ); } m_flStartTime = gpGlobals->curtime; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CRagdollProp::InitRagdollAnimation() { m_flAnimTime = gpGlobals->curtime; m_flPlaybackRate = 0.0; SetCycle( 0 ); // put into ACT_DIERAGDOLL if it exists, otherwise use sequence 0 int nSequence = SelectWeightedSequence( ACT_DIERAGDOLL ); if ( nSequence < 0 ) { ResetSequence( 0 ); } else { ResetSequence( nSequence ); } }
//----------------------------------------------------------------------------- // Purpose: If the animation parity of the weapon has changed, we reset cycle to avoid popping //----------------------------------------------------------------------------- void C_BaseViewModel::UpdateAnimationParity( void ) { C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); // If we're predicting, then we don't use animation parity because we change the animations on the clientside // while predicting. When not predicting, only the server changes the animations, so a parity mismatch // tells us if we need to reset the animation. if ( m_nOldAnimationParity != m_nAnimationParity && !GetPredictable() ) { float curtime = (pPlayer && IsIntermediateDataAllocated()) ? pPlayer->GetFinalPredictedTime() : gpGlobals->curtime; // FIXME: this is bad // Simulate a networked m_flAnimTime and m_flCycle // FIXME: Do we need the magic 0.1? SetCycle( 0.0f ); // GetSequenceCycleRate( GetSequence() ) * 0.1; m_flAnimTime = curtime; } }
ULONG INIT_Frame(piClass *cl,piObject *o,Msg msg) { struct Node_Frame *nf; ULONG active=0; struct Window *PropsWnd=NULL; piGetAttr(o,OBJ_Node,(ULONG *)&nf); GetAttr(PAGE_Active,PropertiesGadgets[GD_PROPERTIES_PAGES], &active); if(active==0) PropsWnd=PropertiesWnd; else PropsWnd=NULL; SetInteger(PropsWnd,PGFR_GeneralGadgets[GD_PGFR_X],nf->nf_X); SetInteger(PropsWnd,PGFR_GeneralGadgets[GD_PGFR_Y],nf->nf_Y); SetInteger(PropsWnd,PGFR_GeneralGadgets[GD_PGFR_WIDTH],nf->nf_Width); SetInteger(PropsWnd,PGFR_GeneralGadgets[GD_PGFR_HEIGHT],nf->nf_Height); SetCycle(PropsWnd,PGFR_GeneralGadgets[GD_PGFR_FRAME],nf->nf_FrameType); SetCheckMark(PropsWnd,PGFR_GeneralGadgets[GD_PGFR_RECESSED],(nf->nf_Flags&MYFR_Recessed)?TRUE:FALSE); return TRUE; }
//------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CPropVehicleChoreoGeneric::InputOpen( inputdata_t &inputdata ) { int nSequence = LookupSequence( "open" ); // Set to the desired anim, or default anim if the desired is not present if ( nSequence > ACTIVITY_NOT_AVAILABLE ) { SetCycle( 0 ); m_flAnimTime = gpGlobals->curtime; ResetSequence( nSequence ); ResetClientsideFrame(); } else { // Not available try to get default anim Msg( "Choreo Generic Vehicle %s: missing open sequence\n", GetDebugName() ); SetSequence( 0 ); } }
void CNewWallHealth::StudioFrameAdvance( void ) { m_flPlaybackRate = 0; float flMaxJuice = sk_healthcharger.GetFloat(); SetCycle( 1.0f - (float)( m_flJuice / flMaxJuice ) ); // Msg( "Cycle: %f - Juice: %d - m_flJuice :%f - Interval: %f\n", (float)GetCycle(), (int)m_iJuice, (float)m_flJuice, GetAnimTimeInterval() ); if ( !m_flPrevAnimTime ) { m_flPrevAnimTime = gpGlobals->curtime; } // Latch prev m_flPrevAnimTime = m_flAnimTime; // Set current m_flAnimTime = gpGlobals->curtime; }
void CAnimating::ResetSequence(int nSequence) { if ( !SequenceLoops() ) { SetCycle( 0 ); } // Tracker 17868: If the sequence number didn't actually change, but you call resetsequence info, it changes // the newsequenceparity bit which causes the client to call m_flCycle.Reset() which causes a very slight // discontinuity in looping animations as they reset around to cycle 0.0. This was causing the parentattached // helmet on barney to hitch every time barney's idle cycled back around to its start. bool changed = nSequence != GetSequence() ? true : false; SetSequence( nSequence ); if ( changed || !SequenceLoops() ) { ResetSequenceInfo(); } }
//----------------------------------------------------------------------------- // Purpose: // Input : eNewActivity - //----------------------------------------------------------------------------- void CNPC_Crow::OnChangeActivity( Activity eNewActivity ) { // if ( eNewActivity == ACT_FLY ) // { // m_flGroundSpeed = CROW_AIRSPEED; // } // bool fRandomize = false; if ( eNewActivity == ACT_FLY ) { fRandomize = true; } BaseClass::OnChangeActivity( eNewActivity ); if ( fRandomize ) { SetCycle( random->RandomFloat( 0.0, 0.75 ) ); } }
void CTripmineGrenade::Spawn( void ) { Precache( ); // motor SetMoveType( MOVETYPE_FLY ); SetSolid( SOLID_BBOX ); SetModel( "models/Weapons/w_slam.mdl" ); IPhysicsObject *pObject = VPhysicsInitNormal( SOLID_BBOX, GetSolidFlags() | FSOLID_TRIGGER, true ); pObject->EnableMotion( false ); SetCollisionGroup( COLLISION_GROUP_WEAPON ); SetCycle( 0.0f ); m_nBody = 3; m_flDamage = sk_plr_dmg_tripmine.GetFloat(); m_DmgRadius = sk_tripmine_radius.GetFloat(); ResetSequenceInfo( ); m_flPlaybackRate = 0; UTIL_SetSize(this, Vector( -4, -4, -2), Vector(4, 4, 2)); m_flPowerUp = gpGlobals->curtime + 2.0; SetThink( &CTripmineGrenade::PowerupThink ); SetNextThink( gpGlobals->curtime + 0.2 ); m_takedamage = DAMAGE_YES; m_iHealth = 1; EmitSound( "TripmineGrenade.Place" ); SetDamage ( 200 ); // Tripmine sits at 90 on wall so rotate back to get m_vecDir QAngle angles = GetAbsAngles(); angles.x -= 90; AngleVectors( angles, &m_vecDir ); m_vecEnd = GetAbsOrigin() + m_vecDir * 2048; AddEffects( EF_NOSHADOW ); }
void CNewRecharge::StudioFrameAdvance( void ) { m_flPlaybackRate = 0; float flMaxJuice = MaxJuice() + 0.1f; float flNewJuice = 1.0f - (float)( m_flJuice / flMaxJuice ); SetCycle( flNewJuice ); // Msg( "Cycle: %f - Juice: %d - m_flJuice :%f - Interval: %f\n", (float)GetCycle(), (int)m_iJuice, (float)m_flJuice, GetAnimTimeInterval() ); if ( !m_flPrevAnimTime ) { m_flPrevAnimTime = gpGlobals->curtime; } // Latch prev m_flPrevAnimTime = m_flAnimTime; // Set current m_flAnimTime = gpGlobals->curtime; }
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 ); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CPropVehicleViewController::InputForcePlayerIn( inputdata_t &inputdata ) { #ifdef SecobMod__Enable_Fixed_Multiplayer_AI CBasePlayer *pPlayer = UTIL_GetNearestPlayer(GetAbsOrigin()); #else CBasePlayer *pPlayer = UTIL_PlayerByIndex(1); #endif //SecobMod__Enable_Fixed_Multiplayer_AI if ( !pPlayer ) return; ResetUseKey( pPlayer ); // Get the entry animation from the input int iEntryAnim = ACTIVITY_NOT_AVAILABLE; if ( inputdata.value.StringID() != NULL_STRING ) { iEntryAnim = LookupSequence( inputdata.value.String() ); if ( iEntryAnim == ACTIVITY_NOT_AVAILABLE ) { Warning("vehicle_viewcontroller %s could not find specified entry animation %s\n", STRING(GetEntityName()), inputdata.value.String() ); return; } } // Make sure we successfully got in the vehicle if ( pPlayer->GetInVehicle( GetServerVehicle(), VEHICLE_ROLE_DRIVER ) == false ) { // The player was unable to enter the vehicle and the output has failed Assert( 0 ); return; } // Setup the "enter" vehicle sequence SetCycle( 0 ); m_flAnimTime = gpGlobals->curtime; ResetSequence( iEntryAnim ); ResetClientsideFrame(); m_bEnterAnimOn = true; }
//----------------------------------------------------------------------------- // Purpose: If the player uses the jeep while at the back, he gets ammo from the crate instead //----------------------------------------------------------------------------- void CASW_PropJeep::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { CBasePlayer *pPlayer = ToBasePlayer( pActivator ); if ( pPlayer == NULL) return; // Find out if the player's looking at our ammocrate hitbox Vector vecForward; pPlayer->EyeVectors( &vecForward, NULL, NULL ); trace_t tr; Vector vecStart = pPlayer->EyePosition(); UTIL_TraceLine( vecStart, vecStart + vecForward * 1024, MASK_SOLID | CONTENTS_DEBRIS | CONTENTS_HITBOX, pPlayer, COLLISION_GROUP_NONE, &tr ); if ( tr.m_pEnt == this && tr.hitgroup == JEEP_AMMOCRATE_HITGROUP ) { // Player's using the crate. // Fill up his SMG ammo. pPlayer->GiveAmmo( 300, "SMG1"); if ( ( GetSequence() != LookupSequence( "ammo_open" ) ) && ( GetSequence() != LookupSequence( "ammo_close" ) ) ) { // Open the crate m_flAnimTime = gpGlobals->curtime; m_flPlaybackRate = 0.0; SetCycle( 0 ); ResetSequence( LookupSequence( "ammo_open" ) ); CPASAttenuationFilter sndFilter( this, "PropJeep.AmmoOpen" ); EmitSound( sndFilter, entindex(), "PropJeep.AmmoOpen" ); } m_flAmmoCrateCloseTime = gpGlobals->curtime + JEEP_AMMO_CRATE_CLOSE_DELAY; return; } // Fall back and get in the vehicle instead BaseClass::Use( pActivator, pCaller, useType, value ); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CItem_AmmoCrate::Spawn( void ) { Precache(); BaseClass::Spawn(); SetModel( STRING( GetModelName() ) ); SetMoveType( MOVETYPE_NONE ); SetSolid( SOLID_VPHYSICS ); CreateVPhysics(); ResetSequence( LookupSequence( "Idle" ) ); SetBodygroup( 1, true ); m_flCloseTime = gpGlobals->curtime; m_flAnimTime = gpGlobals->curtime; m_flPlaybackRate = 0.0; SetCycle( 0 ); m_takedamage = DAMAGE_EVENTS_ONLY; }
//----------------------------------------------------------------------------- // Purpose: // Input : sequence - //----------------------------------------------------------------------------- void CBaseViewModel::SendViewModelMatchingSequence( int sequence ) { // since all we do is send a sequence number down to the client, // set this here so other weapons code knows which sequence is playing. SetSequence( sequence ); m_nAnimationParity = ( m_nAnimationParity + 1 ) & ( (1<<VIEWMODEL_ANIMATION_PARITY_BITS) - 1 ); #if defined( CLIENT_DLL ) m_nOldAnimationParity = m_nAnimationParity; // Force frame interpolation to start at exactly frame zero m_flAnimTime = gpGlobals->curtime; #else CBaseCombatWeapon *weapon = m_hWeapon.Get(); bool showControlPanels = weapon && weapon->ShouldShowControlPanels(); SetControlPanelsActive( showControlPanels ); #endif // Restart animation at frame 0 SetCycle( 0 ); ResetSequenceInfo(); }
void CNewRecharge::Off(void) { // Stop looping sound. if (m_iOn > 1) { StopSound( "SuitRecharge.ChargingLoop" ); } if ( m_nState == 1 ) { SetCycle( 1.0f ); } m_iOn = 0; m_flJuice = m_iJuice; if ( m_iReactivate == 0 ) { if ((!m_iJuice) && g_pGameRules->FlHEVChargerRechargeTime() > 0 ) { if ( HasSpawnFlags( SF_CITADEL_RECHARGER ) ) { m_iReactivate = g_pGameRules->FlHEVChargerRechargeTime() * 2; } else { m_iReactivate = g_pGameRules->FlHEVChargerRechargeTime(); } SetNextThink( gpGlobals->curtime + m_iReactivate ); SetThink(&CNewRecharge::Recharge); } else { SetThink( NULL ); } } }
void CASW_Simple_Alien::Spawn(void) { BaseClass::Spawn(); Precache(); // appearance SetModel( SWARM_NEW_DRONE_MODEL ); m_flAnimTime = gpGlobals->curtime; SetCycle( 0 ); PlayRunningAnimation(); // collision SetHullType( HULL_MEDIUMBIG ); UTIL_SetSize(this, Vector(-19,-19,0), Vector(19,19,69)); SetSolid( SOLID_BBOX ); AddSolidFlags( FSOLID_NOT_STANDABLE ); SetCollisionGroup( ASW_COLLISION_GROUP_ALIEN ); // movement SetMoveType( MOVETYPE_STEP ); m_fArrivedTolerance = 30.0f; // health m_iHealth = ASWGameRules()->ModifyAlienHealthBySkillLevel(asw_drone_health.GetInt()); SetMaxHealth(m_iHealth); m_takedamage = DAMAGE_YES; // state SetState(ASW_SIMPLE_ALIEN_IDLING); SetSleeping(true); m_fLastThinkTime = gpGlobals->curtime; SetThink( &CASW_Simple_Alien::SleepThink ); SetNextThink( gpGlobals->curtime + random->RandomFloat(0.01f, 0.2f) ); UpdateSleeping(); }
//------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CPropVehiclePrisonerPod::InputClose( inputdata_t &inputdata ) { // The enter anim closes the pod, so don't do this redundantly! if ( m_bLocked || m_bEnterAnimOn ) return; int nSequence = LookupSequence( "close" ); // Set to the desired anim, or default anim if the desired is not present if ( nSequence > ACTIVITY_NOT_AVAILABLE ) { SetCycle( 0 ); m_flAnimTime = gpGlobals->curtime; ResetSequence( nSequence ); ResetClientsideFrame(); EmitSound( "d3_citadel.pod_close" ); } else { // Not available try to get default anim Msg( "Prisoner pod %s: missing close sequence\n", GetDebugName() ); SetSequence( 0 ); } }
void C_HL2MPRagdoll::CreateHL2MPRagdoll( 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_HL2MP_Player *pPlayer = dynamic_cast< C_HL2MP_Player* >( m_hPlayer.Get() ); if ( pPlayer && !pPlayer->IsDormant() ) { // move my current model instance to the ragdoll's so decals are preserved. pPlayer->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( pPlayer ); SetAbsAngles( pPlayer->GetRenderAngles() ); GetRotationInterpolator().Reset(); m_flAnimTime = pPlayer->m_flAnimTime; SetSequence( pPlayer->GetSequence() ); m_flPlaybackRate = pPlayer->GetPlaybackRate(); } 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 ); Interp_Reset( GetVarMapping() ); } SetModelIndex( m_nModelIndex ); // Make us a ragdoll.. m_nRenderFX = kRenderFxRagdoll; matrix3x4_t boneDelta0[MAXSTUDIOBONES]; matrix3x4_t boneDelta1[MAXSTUDIOBONES]; matrix3x4_t currentBones[MAXSTUDIOBONES]; const float boneDt = 0.05f; if ( pPlayer && !pPlayer->IsDormant() ) { pPlayer->GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt ); } else { GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt ); } InitAsClientRagdoll( boneDelta0, boneDelta1, currentBones, boneDt ); }
void CNPC_BigMomma::StartTask( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_CHECK_NODE_PROXIMITY: { } break; case TASK_FIND_NODE: { CBaseEntity *pTarget = GetTarget(); if ( !HasMemory( bits_MEMORY_ADVANCE_NODE ) ) { if ( pTarget ) m_iszTarget = pTarget->m_target; } NodeStart( m_iszTarget ); TaskComplete(); //Msg( "BM: Found node %s\n", STRING( m_iszTarget ) ); } break; case TASK_NODE_DELAY: m_nodeTime = gpGlobals->curtime + pTask->flTaskData; TaskComplete(); //Msg( "BM: FAIL! Delay %.2f\n", pTask->flTaskData ); break; case TASK_PROCESS_NODE: //Msg( "BM: Reached node %s\n", STRING( m_iszTarget ) ); NodeReach(); TaskComplete(); break; case TASK_PLAY_NODE_PRESEQUENCE: case TASK_PLAY_NODE_SEQUENCE: { const char *pSequence = NULL; int iSequence; if ( pTask->iTask == TASK_PLAY_NODE_SEQUENCE ) pSequence = GetNodeSequence(); else pSequence = GetNodePresequence(); //Msg( "BM: Playing node sequence %s\n", pSequence ); if ( pSequence ) //ugh { iSequence = LookupSequence( pSequence ); if ( iSequence != -1 ) { SetIdealActivity( ACT_DO_NOT_DISTURB ); SetSequence( iSequence ); SetCycle( 0.0f ); ResetSequenceInfo(); //Msg( "BM: Sequence %s %f\n", GetNodeSequence(), gpGlobals->curtime ); return; } } TaskComplete(); } break; case TASK_NODE_YAW: GetMotor()->SetIdealYaw( GetNodeYaw() ); TaskComplete(); break; case TASK_WAIT_NODE: m_flWait = gpGlobals->curtime + GetNodeDelay(); /*if ( GetTarget() && GetTarget()->GetSpawnFlags() & SF_INFOBM_WAIT ) Msg( "BM: Wait at node %s forever\n", STRING( m_iszTarget) ); else Msg( "BM: Wait at node %s for %.2f\n", STRING( m_iszTarget ), GetNodeDelay() );*/ break; case TASK_MOVE_TO_NODE_RANGE: { CBaseEntity *pTarget = GetTarget(); if ( !pTarget ) TaskFail( FAIL_NO_TARGET ); else { if ( ( pTarget->GetAbsOrigin() - GetAbsOrigin() ).Length() < GetNodeRange() ) TaskComplete(); else { Activity act = ACT_WALK; if ( pTarget->GetSpawnFlags() & SF_INFOBM_RUN ) act = ACT_RUN; AI_NavGoal_t goal( GOALTYPE_TARGETENT, vec3_origin, act ); if ( !GetNavigator()->SetGoal( goal ) ) { TaskFail( NO_TASK_FAILURE ); } } } } //Msg( "BM: Moving to node %s\n", STRING( m_iszTarget ) ); break; case TASK_MELEE_ATTACK1: { // Play an attack sound here CPASAttenuationFilter filter( this ); EmitSound( filter, entindex(), "BigMomma.Attack" ); BaseClass::StartTask( pTask ); } break; default: BaseClass::StartTask( pTask ); break; } }
void C_SDKRagdoll::CreateRagdoll() { // 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_SDKPlayer *pPlayer = dynamic_cast< C_SDKPlayer* >( m_hPlayer.Get() ); if ( pPlayer && !pPlayer->IsDormant() ) { // move my current model instance to the ragdoll's so decals are preserved. pPlayer->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. if ( !pPlayer->IsLocalPlayer() && pPlayer->IsInterpolationEnabled() ) { Interp_Copy( pPlayer ); SetAbsAngles( pPlayer->GetRenderAngles() ); GetRotationInterpolator().Reset(); m_flAnimTime = pPlayer->m_flAnimTime; SetSequence( pPlayer->GetSequence() ); m_flPlaybackRate = pPlayer->GetPlaybackRate(); } 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 = LookupSequence( "RagdollSpawn" ); // hax, find a neutral standing pose if ( iSeq == -1 ) { Assert( false ); // missing look_idle? iSeq = 0; } SetSequence( iSeq ); // look_idle, basic pose SetCycle( 0.0 ); Interp_Reset( varMap ); } m_nBody = pPlayer->GetBody(); } else { // overwrite network origin so later interpolation will // use this position SetNetworkOrigin( m_vecRagdollOrigin ); SetAbsOrigin( m_vecRagdollOrigin ); SetAbsVelocity( m_vecRagdollVelocity ); Interp_Reset( GetVarMapping() ); } SetModelIndex( m_nModelIndex ); // Turn it into a ragdoll. if ( cl_ragdoll_physics_enable.GetInt() ) { // Make us a ragdoll.. m_nRenderFX = kRenderFxRagdoll; matrix3x4_t boneDelta0[MAXSTUDIOBONES]; matrix3x4_t boneDelta1[MAXSTUDIOBONES]; matrix3x4_t currentBones[MAXSTUDIOBONES]; const float boneDt = 0.05f; if ( pPlayer && pPlayer == C_BasePlayer::GetLocalPlayer() ) { pPlayer->GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt ); } else { GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt ); } InitAsClientRagdoll( boneDelta0, boneDelta1, currentBones, boneDt ); } else { ClientLeafSystem()->SetRenderGroup( GetRenderHandle(), RENDER_GROUP_TRANSLUCENT_ENTITY ); } // Fade out the ragdoll in a while StartFadeOut( cl_ragdoll_fade_time.GetFloat() ); SetNextClientThink( gpGlobals->curtime + 5.0f ); }
void CNPC_BaseTurret::SetTurretAnim( TURRET_ANIM anim ) { /* if (GetSequence() != anim) { switch(anim) { case TURRET_ANIM_FIRE: case TURRET_ANIM_SPIN: if (GetSequence() != TURRET_ANIM_FIRE && GetSequence() != TURRET_ANIM_SPIN) { m_flCycle = 0; } break; default: m_flCycle = 0; break; } SetSequence( anim ); ResetSequenceInfo( ); switch(anim) { case TURRET_ANIM_RETIRE: m_flCycle = 255; m_flPlaybackRate = -1.0; //play the animation backwards break; case TURRET_ANIM_DIE: m_flPlaybackRate = 1.0; break; } //ALERT(at_console, "Turret anim #%d\n", anim); } */ if (GetSequence() != anim) { SetSequence( anim ); ResetSequenceInfo( ); switch(anim) { case TURRET_ANIM_FIRE: case TURRET_ANIM_SPIN: if (GetSequence() != TURRET_ANIM_FIRE && GetSequence() != TURRET_ANIM_SPIN) { SetCycle( 0 ); } break; case TURRET_ANIM_RETIRE: SetCycle( 1.0 ); m_flPlaybackRate = -1.0; //play the animation backwards break; case TURRET_ANIM_DIE: SetCycle( 0.0 ); m_flPlaybackRate = 1.0; break; default: SetCycle( 0 ); break; } } }
// Set the activity based on an event or current state void CHL2MP_Player::SetAnimation( PLAYER_ANIM playerAnim ) { int animDesired; float speed; speed = GetAbsVelocity().Length2D(); // bool bRunning = true; //Revisit! /* if ( ( m_nButtons & ( IN_FORWARD | IN_BACK | IN_MOVELEFT | IN_MOVERIGHT ) ) ) { if ( speed > 1.0f && speed < hl2_normspeed.GetFloat() - 20.0f ) { bRunning = false; } }*/ if ( GetFlags() & ( FL_FROZEN | FL_ATCONTROLS ) ) { speed = 0; playerAnim = PLAYER_IDLE; } Activity idealActivity = ACT_HL2MP_RUN; // This could stand to be redone. Why is playerAnim abstracted from activity? (sjb) if ( playerAnim == PLAYER_JUMP ) { idealActivity = ACT_HL2MP_JUMP; } else if ( playerAnim == PLAYER_DIE ) { if ( m_lifeState == LIFE_ALIVE ) { return; } } else if ( playerAnim == PLAYER_ATTACK1 ) { if ( GetActivity( ) == ACT_HOVER || GetActivity( ) == ACT_SWIM || GetActivity( ) == ACT_HOP || GetActivity( ) == ACT_LEAP || GetActivity( ) == ACT_DIESIMPLE ) { idealActivity = GetActivity( ); } else { idealActivity = ACT_HL2MP_GESTURE_RANGE_ATTACK; } } else if ( playerAnim == PLAYER_RELOAD ) { idealActivity = ACT_HL2MP_GESTURE_RELOAD; } else if ( playerAnim == PLAYER_IDLE || playerAnim == PLAYER_WALK ) { if ( !( GetFlags() & FL_ONGROUND ) && GetActivity( ) == ACT_HL2MP_JUMP ) // Still jumping { idealActivity = GetActivity( ); } /* else if ( GetWaterLevel() > 1 ) { if ( speed == 0 ) idealActivity = ACT_HOVER; else idealActivity = ACT_SWIM; } */ else { if ( GetFlags() & FL_DUCKING ) { if ( speed > 0 ) { idealActivity = ACT_HL2MP_WALK_CROUCH; } else { idealActivity = ACT_HL2MP_IDLE_CROUCH; } } else { if ( speed > 0 ) { /* if ( bRunning == false ) { idealActivity = ACT_WALK; } else */ { idealActivity = ACT_HL2MP_RUN; } } else { idealActivity = ACT_HL2MP_IDLE; } } } idealActivity = TranslateTeamActivity( idealActivity ); } if ( idealActivity == ACT_HL2MP_GESTURE_RANGE_ATTACK ) { RestartGesture( Weapon_TranslateActivity( idealActivity ) ); // FIXME: this seems a bit wacked Weapon_SetActivity( Weapon_TranslateActivity( ACT_RANGE_ATTACK1 ), 0 ); return; } else if ( idealActivity == ACT_HL2MP_GESTURE_RELOAD ) { RestartGesture( Weapon_TranslateActivity( idealActivity ) ); return; } else { SetActivity( idealActivity ); animDesired = SelectWeightedSequence( Weapon_TranslateActivity ( idealActivity ) ); if (animDesired == -1) { animDesired = SelectWeightedSequence( idealActivity ); if ( animDesired == -1 ) { animDesired = 0; } } // Already using the desired animation? if ( GetSequence() == animDesired ) return; m_flPlaybackRate = 1.0; ResetSequence( animDesired ); SetCycle( 0 ); return; } // Already using the desired animation? if ( GetSequence() == animDesired ) return; //Msg( "Set animation to %d\n", animDesired ); // Reset to first frame of desired animation ResetSequence( animDesired ); SetCycle( 0 ); }