//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFuncRespawnRoomVisualizer::SetActive( bool bActive )
{
if ( bActive )
{
// We're a trigger, but we want to be solid. Out ShouldCollide() will make
// us non-solid to members of the team that spawns here.
RemoveSolidFlags( FSOLID_TRIGGER );
RemoveSolidFlags( FSOLID_NOT_SOLID );
}
else
{
AddSolidFlags( FSOLID_NOT_SOLID );
AddSolidFlags( FSOLID_TRIGGER );
}
}
//-----------------------------------------------------------------------------
// Activate when at rest, but don't allow pickup until then
//-----------------------------------------------------------------------------
void CItem::ActivateWhenAtRest()
{
RemoveSolidFlags( FSOLID_TRIGGER );
m_bActivateWhenAtRest = true;
SetThink( &CItem::ComeToRest );
SetNextThink( gpGlobals->curtime + 0.5f );
}
void CRocketMissile::IgniteThink( void )
{
SetMoveType( MOVETYPE_FLY );
SetModel("models/weapons/w_missile.mdl");
UTIL_SetSize( this, vec3_origin, vec3_origin );
RemoveSolidFlags( FSOLID_NOT_SOLID );
//TODO: Play opening sound
Vector vecForward;
EmitSound( "Missile.Ignite" );
AngleVectors( GetLocalAngles(), &vecForward );
SetAbsVelocity( vecForward * BALANCE_VALUE( Float, lfm_rocket_launcher_speed ) );
// Hmmm...
//SetThink( &CRocketMissile::SeekThink );
//SetNextThink( gpGlobals->curtime );
if ( m_hOwner && m_hOwner->GetOwner() )
{
CBasePlayer *pPlayer = ToBasePlayer( m_hOwner->GetOwner() );
color32 white = { 255,225,205,64 };
UTIL_ScreenFade( pPlayer, white, 0.1f, 0.0f, FFADE_IN );
}
CreateSmokeTrail();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPlayer_Missile::InputActivate( inputdata_t &inputdata )
{
// Make sure not already active
if (m_bActive)
{
return;
}
BaseClass::InputActivate( inputdata );
Vector origin = GetLocalOrigin();
origin.z += 50;
SetLocalOrigin( origin );
RemoveSolidFlags( FSOLID_NOT_SOLID );
Relink();
// Using player angles to determine turning. Initailze to 0,0,0
CHL2_Player* pPlayer = (CHL2_Player*)UTIL_PlayerByIndex( 1 );
Assert( pPlayer );
pPlayer->SetLocalAngles( vec3_angle ); // Note: Set GetLocalAngles(), not pl.v_angle
pPlayer->SnapEyeAngles( vec3_angle ); // Force reset
pPlayer->SetFOV( 100 );
engine->SetView( pPlayer->edict(), edict() );
m_flStatic = 0;
SetThink(Launch);
SetNextThink( gpGlobals->curtime + m_flLaunchDelay );
}
void CFuncVehicleClip::InputEnable( inputdata_t &data )
{
IPhysicsObject *pPhys = VPhysicsGetObject();
if ( pPhys )
{
pPhys->EnableCollisions( true );
}
RemoveSolidFlags( FSOLID_NOT_SOLID );
}
void CTripwireGrenade::PowerupThink( void )
{
if (gpGlobals->curtime > m_flPowerUp)
{
MakeRope( );
RemoveSolidFlags( FSOLID_NOT_SOLID );
m_bIsLive = true;
}
SetNextThink( gpGlobals->curtime + 0.1f );
}
void CSDKPlayer::Spawn()
{
SetModel( SDK_PLAYER_MODEL );
SetMoveType( MOVETYPE_WALK );
RemoveSolidFlags( FSOLID_NOT_SOLID );
m_hRagdoll = NULL;
BaseClass::Spawn();
}
void CFuncWallToggle::TurnOn( void )
{
IPhysicsObject *pPhys = VPhysicsGetObject();
if ( pPhys )
{
pPhys->EnableCollisions( true );
}
RemoveSolidFlags( FSOLID_NOT_SOLID );
RemoveEffects( EF_NODRAW );
}
void CSDKPlayer::State_Enter_ACTIVE()
{
SetMoveType( MOVETYPE_WALK );
RemoveSolidFlags( FSOLID_NOT_SOLID );
m_Local.m_iHideHUD = 0;
PhysObjectWake();
//Tony; call spawn again now -- remember; when we add respawn timers etc, to just put them into the spawn queue, and let the queue respawn them.
Spawn();
}
//-----------------------------------------------------------------------------
// Purpose: Sets HL2 specific defaults.
//-----------------------------------------------------------------------------
void CHL2MP_Player::Spawn(void)
{
#ifdef GE_DLL
m_bSpawnInterpCounter = !m_bSpawnInterpCounter;
BaseClass::Spawn();
#else
m_flNextModelChangeTime = 0.0f;
m_flNextTeamChangeTime = 0.0f;
PickDefaultSpawnTeam();
BaseClass::Spawn();
if ( !IsObserver() )
{
pl.deadflag = false;
RemoveSolidFlags( FSOLID_NOT_SOLID );
RemoveEffects( EF_NODRAW );
GiveDefaultItems();
}
RemoveEffects( EF_NOINTERP );
m_nRenderFX = kRenderNormal;
m_Local.m_iHideHUD = 0;
AddFlag(FL_ONGROUND); // set the player on the ground at the start of the round.
m_impactEnergyScale = HL2MPPLAYER_PHYSDAMAGE_SCALE;
if ( HL2MPRules()->IsIntermission() )
{
AddFlag( FL_FROZEN );
}
else
{
RemoveFlag( FL_FROZEN );
}
m_bSpawnInterpCounter = !m_bSpawnInterpCounter;
m_Local.m_bDucked = false;
SetPlayerUnderwater(false);
m_bReady = false;
#endif
//Tony; do the spawn animevent
DoAnimationEvent( PLAYERANIMEVENT_SPAWN );
SetContextThink( &CHL2MP_Player::HL2MPPushawayThink, gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL, HL2MP_PUSHAWAY_THINK_CONTEXT );
}
void CTripmineGrenade::BeamBreakThink( void )
{
// See if I can go solid yet (has dropper moved out of way?)
if (IsSolidFlagSet( FSOLID_NOT_SOLID ))
{
trace_t tr;
Vector vUpBit = GetAbsOrigin();
vUpBit.z += 5.0;
UTIL_TraceEntity( this, GetAbsOrigin(), vUpBit, MASK_SHOT, &tr );
if ( !tr.startsolid && (tr.fraction == 1.0) )
{
RemoveSolidFlags( FSOLID_NOT_SOLID );
}
}
trace_t tr;
// NOT MASK_SHOT because we want only simple hit boxes
UTIL_TraceLine( GetAbsOrigin(), m_vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
// ALERT( at_console, "%f : %f\n", tr.flFraction, m_flBeamLength );
// respawn detect.
if ( !m_pBeam )
{
MakeBeam( );
if ( tr.m_pEnt )
m_hOwner = tr.m_pEnt; // reset owner too
}
CBaseEntity *pEntity = tr.m_pEnt;
CBaseCombatCharacter *pBCC = ToBaseCombatCharacter( pEntity );
bool bAttachMoved = false;
if ( m_bAttached && m_hAttachEntity.Get() != NULL )
{
if ( m_hAttachEntity.Get()->GetAbsOrigin() != m_vAttachedPosition )
bAttachMoved = true;
}
// Also blow up if the attached entity goes away, ie: a crate
if (pBCC || fabs( m_flBeamLength - tr.fraction ) > 0.001 || ( m_bAttached && m_hAttachEntity.Get() == NULL) || bAttachMoved )
{
m_iHealth = 0;
if (m_pConstraint)
m_pConstraint->Deactivate();
Event_Killed( CTakeDamageInfo( (CBaseEntity*)m_hOwner, this, 100, GIB_NORMAL ) );
return;
}
SetNextThink( gpGlobals->curtime + 0.05f );
}
void CBaseNetworkedPlayer::Spawn()
{
BaseClass::Spawn();
// used to not interp players when they spawn
m_bSpawnInterpCounter = !m_bSpawnInterpCounter;
RemoveSolidFlags( FSOLID_NOT_SOLID );
RemoveRagdollEntity();
}
//-----------------------------------------------------------------------------
// Purpose: Shows the brush.
//-----------------------------------------------------------------------------
void CFuncBrush::TurnOn( void )
{
if ( IsOn() )
return;
if ( m_iSolidity != BRUSHSOLID_NEVER )
{
RemoveSolidFlags( FSOLID_NOT_SOLID );
}
RemoveEffects( EF_NODRAW );
}
void CTripwireGrenade::RopeBreakThink( void )
{
// See if I can go solid yet (has dropper moved out of way?)
if (IsSolidFlagSet(FSOLID_NOT_SOLID))
{
trace_t tr;
Vector vUpBit = GetAbsOrigin();
vUpBit.z += 5.0;
UTIL_TraceEntity( this, GetAbsOrigin(), vUpBit, MASK_SHOT, &tr );
if ( !tr.startsolid && (tr.fraction == 1.0) )
{
RemoveSolidFlags( FSOLID_NOT_SOLID );
}
}
// Check if rope had gotten beyond it's max length
float flRopeLength = (GetAbsOrigin()-m_pHook->GetAbsOrigin()).Length();
if (flRopeLength > TGRENADE_MAX_ROPE_LEN)
{
// Shoot missiles at hook
m_iHealth = 0;
BreakRope();
m_vTargetPos = m_pHook->GetAbsOrigin();
CrossProduct ( m_vecDir, Vector(0,0,1), m_vTargetOffset );
m_vTargetOffset *=TGRENADE_MISSILE_OFFSET;
SetThink(FireThink);
FireThink();
}
// Check to see if can see hook
// NOT MASK_SHOT because we want only simple hit boxes
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), m_pHook->GetAbsOrigin(), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
// If can't see hook
CBaseEntity *pEntity = tr.m_pEnt;
if (tr.fraction != 1.0 && pEntity != m_pHook)
{
// Shoot missiles at place where rope was intersected
m_iHealth = 0;
BreakRope();
m_vTargetPos = tr.endpos;
CrossProduct ( m_vecDir, Vector(0,0,1), m_vTargetOffset );
m_vTargetOffset *=TGRENADE_MISSILE_OFFSET;
SetThink(FireThink);
FireThink();
return;
}
SetNextThink( gpGlobals->curtime + 0.1f );
}
//-----------------------------------------------------------------------------
// Purpose: Sets HL2 specific defaults.
//-----------------------------------------------------------------------------
void CHL2MP_Player::Spawn(void)
{
m_flNextModelChangeTime = 0.0f;
m_flNextTeamChangeTime = 0.0f;
PickDefaultSpawnTeam();
BaseClass::Spawn();
pl.deadflag = false;
m_lifeState = LIFE_ALIVE;
RemoveSolidFlags( FSOLID_NOT_SOLID );
RemoveEffects( EF_NODRAW );
//BP On donne par défaut les armes correspondantes au mode de jeu
//GiveDefaultItems();
GiveAllItems();
RemoveEffects( EF_NOINTERP );
m_nRenderFX = kRenderNormal;
m_Local.m_iHideHUD = 0;
AddFlag(FL_ONGROUND); // set the player on the ground at the start of the round.
m_impactEnergyScale = HL2MPPLAYER_PHYSDAMAGE_SCALE;
if ( HL2MPRules()->IsIntermission() )
AddFlag( FL_FROZEN );
else
RemoveFlag( FL_FROZEN );
m_bSpawnInterpCounter = !m_bSpawnInterpCounter;
m_Local.m_bDucked = false;
SetPlayerUnderwater(false);
m_bReady = false;
m_hKiller.Set(NULL);
//Tony; do the spawn animevent
DoAnimationEvent( PLAYERANIMEVENT_SPAWN );
SetContextThink( &CHL2MP_Player::HL2MPPushawayThink, gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL, HL2MP_PUSHAWAY_THINK_CONTEXT );
if ( GetTeamNumber() != TEAM_SPECTATOR )
StopObserverMode();
}
void CTripmineGrenade::PowerupThink( void )
{
if (gpGlobals->curtime > m_flPowerUp)
{
MakeBeam( );
RemoveSolidFlags( FSOLID_NOT_SOLID );
m_bIsLive = true;
// play enabled sound
EmitSound( "TripmineGrenade.Activate" );
}
SetNextThink( gpGlobals->curtime + 0.1f );
}
//-----------------------------------------------------------------------------
// Purpose: Sets HL2 specific defaults.
//-----------------------------------------------------------------------------
void CHL2MP_Player::Spawn(void)
{
m_flNextModelChangeTime = 0.0f;
m_flNextTeamChangeTime = 0.0f;
PickDefaultSpawnTeam();
BaseClass::Spawn();
if ( !IsObserver() )
{
pl.deadflag = false;
RemoveSolidFlags( FSOLID_NOT_SOLID );
RemoveEffects( EF_NODRAW );
GiveDefaultItems();
}
SetNumAnimOverlays( 3 );
ResetAnimation();
m_nRenderFX = kRenderNormal;
m_Local.m_iHideHUD = 0;
AddFlag(FL_ONGROUND); // set the player on the ground at the start of the round.
m_impactEnergyScale = HL2MPPLAYER_PHYSDAMAGE_SCALE;
if ( HL2MPRules()->IsIntermission() )
{
AddFlag( FL_FROZEN );
}
else
{
RemoveFlag( FL_FROZEN );
}
m_iSpawnInterpCounter = (m_iSpawnInterpCounter + 1) % 8;
m_Local.m_bDucked = false;
SetPlayerUnderwater(false);
m_bReady = false;
m_flNextKickAttack = gpGlobals->curtime;
CBaseViewModel *Leg = GetViewModel(1);
Leg->SetWeaponModel("models/weapons/v_kick.mdl", NULL);
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CGrenadePathfollower::Launch( float flLaunchSpeed, string_t sPathCornerName)
{
m_pPathTarget = gEntList.FindEntityByName( NULL, sPathCornerName );
if (m_pPathTarget)
{
m_flFlySpeed = flLaunchSpeed;
Vector vTargetDir = (m_pPathTarget->GetAbsOrigin() - GetAbsOrigin());
VectorNormalize(vTargetDir);
SetAbsVelocity( m_flFlySpeed * vTargetDir );
QAngle angles;
VectorAngles( GetAbsVelocity(), angles );
SetLocalAngles( angles );
}
else
{
Warning( "ERROR: Grenade_Pathfollower (%s) with no pathcorner!\n",GetDebugName());
return;
}
// Make this thing come to life
RemoveSolidFlags( FSOLID_NOT_SOLID );
SetMoveType( MOVETYPE_FLYGRAVITY );
RemoveEffects( EF_NODRAW );
SetUse( &CGrenadePathfollower::DetonateUse );
SetTouch( &CGrenadePathfollower::GrenadeTouch );
SetThink( &CGrenadePathfollower::AimThink );
SetNextThink( gpGlobals->curtime + 0.1f );
// Make the trail
m_hRocketTrail = RocketTrail::CreateRocketTrail();
if ( m_hRocketTrail )
{
m_hRocketTrail->m_Opacity = 0.2f;
m_hRocketTrail->m_SpawnRate = 100;
m_hRocketTrail->m_ParticleLifetime = 0.5f;
m_hRocketTrail->m_StartColor.Init( 0.65f, 0.65f , 0.65f );
m_hRocketTrail->m_EndColor.Init( 0.0, 0.0, 0.0 );
m_hRocketTrail->m_StartSize = 8;
m_hRocketTrail->m_EndSize = 16;
m_hRocketTrail->m_SpawnRadius = 4;
m_hRocketTrail->m_MinSpeed = 2;
m_hRocketTrail->m_MaxSpeed = 16;
m_hRocketTrail->SetLifetime( 999 );
m_hRocketTrail->FollowEntity( this, "0" );
}
}
void CGEPropDynamic::Materialize(void)
{
//A more lightweight and optional func_rebreakable materalize function
CreateVPhysics();
if (m_bRobustSpawn)
{
// iterate on all entities in the vicinity.
CBaseEntity *pEntity;
Vector max = CollisionProp()->OBBMaxs();
for (CEntitySphereQuery sphere(GetAbsOrigin(), max.NormalizeInPlace()); (pEntity = sphere.GetCurrentEntity()) != NULL; sphere.NextEntity())
{
if (pEntity == this || pEntity->GetSolid() == SOLID_NONE || pEntity->GetSolid() == SOLID_BSP || pEntity->GetSolidFlags() & FSOLID_NOT_SOLID || pEntity->GetMoveType() & MOVETYPE_NONE)
continue;
// Ignore props that can't move
if (pEntity->VPhysicsGetObject() && !pEntity->VPhysicsGetObject()->IsMoveable())
continue;
// Prevent respawn if we are blocked by anything and try again in 1 second
if (Intersects(pEntity))
{
SetSolid(SOLID_NONE);
AddSolidFlags(FSOLID_NOT_SOLID);
VPhysicsDestroyObject();
SetNextThink(gpGlobals->curtime + 1.0f);
return;
}
}
}
m_iHealth = m_iHealthOverride;
if (m_iHealth > 0)
m_takedamage = DAMAGE_YES;
RemoveEffects(EF_NODRAW);
RemoveSolidFlags(FSOLID_NOT_SOLID);
m_bUsingBrokenSkin = false;
if (m_bUseRandomSkins)
PickNewSkin();
else
m_nSkin = m_iStartingSkin;
SetRenderColor(m_col32basecolor.r, m_col32basecolor.g, m_col32basecolor.b);
m_Respawn.FireOutput(this, this);
}
void CCollisionProperty::UseTriggerBounds( bool bEnable, float flBloat )
{
Assert( flBloat <= 127.0f );
m_triggerBloat = (char )flBloat;
if ( bEnable )
{
AddSolidFlags( FSOLID_USE_TRIGGER_BOUNDS );
Assert( flBloat > 0.0f );
}
else
{
RemoveSolidFlags( FSOLID_USE_TRIGGER_BOUNDS );
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets HL2 specific defaults.
//-----------------------------------------------------------------------------
void CHL2MP_Player::Spawn(void)
{
m_flNextModelChangeTime = 0.0f;
m_flNextTeamChangeTime = 0.0f;
PickDefaultSpawnTeam();
BaseClass::Spawn();
if ( !IsObserver() )
{
pl.deadflag = false;
RemoveSolidFlags( FSOLID_NOT_SOLID );
RemoveEffects( EF_NODRAW );
GiveDefaultItems();
}
m_nRenderFX = kRenderNormal;
m_Local.m_iHideHUD = 0;
AddFlag(FL_ONGROUND); // set the player on the ground at the start of the round.
m_impactEnergyScale = HL2MPPLAYER_PHYSDAMAGE_SCALE;
if ( HL2MPRules()->IsIntermission() )
{
AddFlag( FL_FROZEN );
}
else
{
RemoveFlag( FL_FROZEN );
}
m_iSpawnInterpCounter = (m_iSpawnInterpCounter + 1) % 8;
m_Local.m_bDucked = false;
SetPlayerUnderwater(false);
m_bReady = false;
//Tony; do the spawn animevent
DoAnimationEvent( PLAYERANIMEVENT_SPAWN );
}
void CSDKPlayer::Spawn()
{
SetModel( SDK_PLAYER_MODEL ); //Tony; basically, leave this alone ;) unless you're not using classes or teams, then you can change it to whatever.
SetBloodColor( BLOOD_COLOR_RED );
SetMoveType( MOVETYPE_WALK );
RemoveSolidFlags( FSOLID_NOT_SOLID );
//Tony; if we're spawning in active state, equip the suit so the hud works. -- Gotta love base code !
if ( State_Get() == STATE_ACTIVE )
{
EquipSuit( false );
//Tony; bleh, don't do this here.
// GiveDefaultItems();
}
m_hRagdoll = NULL;
BaseClass::Spawn();
#if defined ( SDK_USE_STAMINA ) || defined ( SDK_USE_SPRINTING )
m_Shared.SetStamina( 100 );
#endif
#if defined ( SDK_USE_TEAMS )
m_bTeamChanged = false;
#endif
#if defined ( SDK_USE_PRONE )
InitProne();
#endif
#if defined ( SDK_USE_SPRINTING )
InitSprinting();
#endif
// update this counter, used to not interp players when they spawn
m_bSpawnInterpCounter = !m_bSpawnInterpCounter;
InitSpeeds(); //Tony; initialize player speeds.
SetArmorValue(SpawnArmorValue());
SetContextThink( &CSDKPlayer::SDKPushawayThink, gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL, SDK_PUSHAWAY_THINK_CONTEXT );
pl.deadflag = false;
}
void CTripmineGrenade::BeamBreakThink( void )
{
// See if I can go solid yet (has dropper moved out of way?)
if (IsSolidFlagSet( FSOLID_NOT_SOLID ))
{
trace_t tr;
Vector vUpBit = GetAbsOrigin();
vUpBit.z += 5.0;
UTIL_TraceEntity( this, GetAbsOrigin(), vUpBit, MASK_SHOT, &tr );
if ( !tr.startsolid && (tr.fraction == 1.0) )
{
RemoveSolidFlags( FSOLID_NOT_SOLID );
}
}
trace_t tr;
// NOT MASK_SHOT because we want only simple hit boxes
UTIL_TraceLine( GetAbsOrigin(), m_vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
// ALERT( at_console, "%f : %f\n", tr.flFraction, m_flBeamLength );
// respawn detect.
if ( !m_pBeam )
{
MakeBeam( );
if ( tr.m_pEnt )
m_hOwner = tr.m_pEnt; // reset owner too
}
CBaseEntity *pEntity = tr.m_pEnt;
CBaseCombatCharacter *pBCC = ToBaseCombatCharacter( pEntity );
if (pBCC && pBCC->GetTeamNumber() != m_nTeam && pBCC->m_floatCloakFactor < 1.0f)
//if (pBCC || fabs( m_flBeamLength - tr.fraction ) > 0.001)
{
m_iHealth = 0;
Event_Killed( CTakeDamageInfo( (CBaseEntity*)m_hOwner, this, 100, GIB_NORMAL ) );
return;
}
SetNextThink( gpGlobals->curtime + 0.05f );
}
void CASW_Rocket::IgniteThink( void )
{
SetMoveType( MOVETYPE_FLY );
SetModel(ASW_ROCKET_MODEL);
UTIL_SetSize( this, vec3_origin, vec3_origin );
RemoveSolidFlags( FSOLID_NOT_SOLID );
//TODO: Play opening sound
Vector vecForward;
AngleVectors( GetLocalAngles(), &vecForward );
SetAbsVelocity( vecForward * ASW_ROCKET_MIN_SPEED );
SetThink( &CASW_Rocket::SeekThink );
SetNextThink( gpGlobals->curtime );
}
void CRagGib::Spawn( const char *szModel, const Vector &vecOrigin, const Vector &vecForce, float flFadeTime = 0.0 )
{
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_SOLID );
SetModel( szModel );
UTIL_SetSize(this, vec3_origin, vec3_origin);
UTIL_SetOrigin( this, vecOrigin );
if ( !BecomeRagdollOnClient( vecForce ) )
{
AddSolidFlags( FSOLID_NOT_STANDABLE );
RemoveSolidFlags( FSOLID_NOT_SOLID );
if( flFadeTime > 0.0 )
{
SUB_StartFadeOut( flFadeTime );
}
}
}
void CTripmineGrenade::PowerupThink( void )
{
if (gpGlobals->curtime > m_flPowerUp)
{
MakeBeam( );
RemoveSolidFlags( FSOLID_NOT_SOLID );
m_bIsLive = true;
// The moment it's live, then do this - incase the attach entity moves between placing it, and activation
// use the absorigin of what we're attaching to for the check, if it moves - we blow up.
if ( m_bAttached && m_hAttachEntity.Get() != NULL )
m_vAttachedPosition = m_hAttachEntity.Get()->GetAbsOrigin();
// play enabled sound
EmitSound( "TripmineGrenade.Activate" );
}
SetNextThink( gpGlobals->curtime + 0.1f );
}
void CHL1MP_Player::Spawn( void )
{
RemoveEffects( EF_NODRAW );
m_flNextModelChangeTime = 0;
m_flNextTeamChangeTime = 0;
SetMoveType( MOVETYPE_WALK );
RemoveSolidFlags( FSOLID_NOT_SOLID );
// if no model, force one
if ( !GetModelPtr() )
SetModel( "models/player/mp/gordon/gordon.mdl" );
BaseClass::Spawn();
GiveDefaultItems();
SetPlayerModel();
m_bHasLongJump = false;
m_iSpawnInterpCounter = (m_iSpawnInterpCounter + 1) % 8;
}
void CRagdollPropAttached::Detach()
{
SetParent(NULL);
SetOwnerEntity( NULL );
SetAbsAngles( vec3_angle );
SetMoveType( MOVETYPE_VPHYSICS );
RemoveSolidFlags( FSOLID_NOT_SOLID );
physenv->DestroyConstraint( m_pAttachConstraint );
m_pAttachConstraint = NULL;
const float dampingScale = 1.0f / ATTACHED_DAMPING_SCALE;
for ( int i = 0; i < m_ragdoll.listCount; i++ )
{
float damping, rotdamping;
m_ragdoll.list[i].pObject->GetDamping( &damping, &rotdamping );
damping *= dampingScale;
rotdamping *= dampingScale;
m_ragdoll.list[i].pObject->SetDamping( &damping, &damping );
}
// Go non-solid
SetCollisionGroup( COLLISION_GROUP_DEBRIS );
RecheckCollisionFilter();
}
void CASW_Parasite::LeapTouch( CBaseEntity *pOther )
{
m_bMidJump = false;
if ( IRelationType( pOther ) == D_HT )
{
if (m_bDefanged)
{
if ( pOther->m_takedamage != DAMAGE_NO )
{
BiteSound();
TouchDamage( pOther );
//ClearSchedule( "About to gib self" );
// gib us
CTakeDamageInfo info(NULL, NULL, Vector(0,0,0), GetAbsOrigin(), GetHealth() * 2,
DMG_ACID);
TakeDamage(info);
SetSchedule( SCHED_DIE );
return;
}
else
{
//ImpactSound();
}
}
// Don't hit if back on ground
//if ( !( GetFlags() & FL_ONGROUND ) && m_bDefanged) // if we're defanged, don't infest, just do some combat damage
//{
//}
//else
//{
//ImpactSound();
//}
}
else if( !(GetFlags() & FL_ONGROUND) )
{
// Still in the air...
if( gpGlobals->curtime < m_flIgnoreWorldCollisionTime )
{
// Headcrabs try to ignore the world, static props, and friends for a
// fraction of a second after they jump. This is because they often brush
// doorframes or props as they leap, and touching those objects turns off
// this touch function, which can cause them to hit the player and not bite.
// A timer probably isn't the best way to fix this, but it's one of our
// safer options at this point (sjb).
return;
}
if( !pOther->IsSolid() )
{
// Touching a trigger or something.
return;
}
}
// make sure we're solid
RemoveSolidFlags( FSOLID_NOT_SOLID );
// Shut off the touch function.
SetTouch( &CASW_Parasite::NormalTouch );
SetThink ( &CASW_Parasite::CallNPCThink );
SetCollisionGroup( ASW_COLLISION_GROUP_PARASITE );
// if we hit a marine, infest him and go away
NormalTouch( pOther );
}
//-----------------------------------------------------------------------------
// Purpose: Called when spawning, after keyvalues have been set.
//-----------------------------------------------------------------------------
void CFuncRotating::Spawn( )
{
#ifdef TF_DLL
AddSpawnFlags( SF_BRUSH_ROTATE_CLIENTSIDE );
#endif
//
// Maintain compatibility with previous maps.
//
if (m_flVolume == 0.0)
{
m_flVolume = 1.0;
}
//
// If the designer didn't set a sound attenuation, default to one.
//
if ( HasSpawnFlags(SF_BRUSH_ROTATE_SMALLRADIUS) )
{
m_flAttenuation = ATTN_IDLE;
}
else if ( HasSpawnFlags(SF_BRUSH_ROTATE_MEDIUMRADIUS) )
{
m_flAttenuation = ATTN_STATIC;
}
else if ( HasSpawnFlags(SF_BRUSH_ROTATE_LARGERADIUS) )
{
m_flAttenuation = ATTN_NORM;
}
else
{
m_flAttenuation = ATTN_NORM;
}
//
// Prevent divide by zero if level designer forgets friction!
//
if ( m_flFanFriction == 0 )
{
m_flFanFriction = 1;
}
//
// Build the axis of rotation based on spawnflags.
//
if ( HasSpawnFlags(SF_BRUSH_ROTATE_Z_AXIS) )
{
m_vecMoveAng = QAngle(0,0,1);
}
else if ( HasSpawnFlags(SF_BRUSH_ROTATE_X_AXIS) )
{
m_vecMoveAng = QAngle(1,0,0);
}
else
{
m_vecMoveAng = QAngle(0,1,0); // y-axis
}
//
// Check for reverse rotation.
//
if ( HasSpawnFlags(SF_BRUSH_ROTATE_BACKWARDS) )
{
m_vecMoveAng = m_vecMoveAng * -1;
}
SetSolid( SOLID_VPHYSICS );
//
// Some rotating objects like fake volumetric lights will not be solid.
//
if ( HasSpawnFlags(SF_ROTATING_NOT_SOLID) )
{
AddSolidFlags( FSOLID_NOT_SOLID );
SetMoveType( MOVETYPE_PUSH );
}
else
{
RemoveSolidFlags( FSOLID_NOT_SOLID );
SetMoveType( MOVETYPE_PUSH );
}
SetModel( STRING( GetModelName() ) );
SetUse( &CFuncRotating::RotatingUse );
//
// Did level designer forget to assign a maximum speed? Prevent a divide by
// zero in RampPitchVol as well as allowing the rotator to work.
//
m_flMaxSpeed = fabs( m_flMaxSpeed );
if (m_flMaxSpeed == 0)
{
m_flMaxSpeed = 100;
}
//
// If the brush should be initially rotating, use it in a little while.
//
if ( HasSpawnFlags(SF_BRUSH_ROTATE_START_ON) )
{
SetThink( &CFuncRotating::SUB_CallUseToggle );
SetNextThink( gpGlobals->curtime + .2 ); // leave a magic delay for client to start up
}
//
// Can this brush inflict pain?
//
if ( HasSpawnFlags(SF_BRUSH_HURT) )
{
SetTouch( &CFuncRotating::HurtTouch );
}
//
// Set speed to 0 in case there's an old "speed" key lying around.
//
m_flSpeed = 0;
Precache( );
CreateVPhysics();
m_angStart = GetLocalAngles();
// Slam the object back to solid - if we really want it to be solid.
if ( m_bSolidBsp )
{
SetSolid( SOLID_BSP );
}
if ( HasSpawnFlags(SF_BRUSH_ROTATE_CLIENTSIDE) )
{
m_vecClientOrigin = GetLocalOrigin();
m_vecClientAngles = GetLocalAngles();
}
}