void CreatureGroup::RespawnAll(Creature* except)
{
for (std::map<ObjectGuid, CreatureGroupMember*>::iterator itr = _members.begin(); itr != _members.end(); ++itr)
if (itr->first != except->GetObjectGuid())
if (Creature* otherMember = except->GetMap()->GetCreature(itr->first))
Respawn(otherMember, itr->second);
if (except->GetObjectGuid() != GetLeaderGuid())
if (Creature* otherMember = except->GetMap()->GetCreature(GetLeaderGuid()))
Respawn(otherMember, NULL);
}
BOOL CHealthKit::MyTouch( CBasePlayer *pPlayer )
{
if ( pPlayer->pev->deadflag != DEAD_NO )
{
return FALSE;
}
if ( pPlayer->TakeHealth( gSkillData.healthkitCapacity, DMG_GENERIC ) )
{
MESSAGE_BEGIN( MSG_ONE, gmsgItemPickup, NULL, pPlayer->pev );
WRITE_STRING( STRING(pev->classname) );
MESSAGE_END();
EMIT_SOUND(ENT(pPlayer->pev), CHAN_ITEM, "items/smallmedkit1.wav", 1, ATTN_NORM);
if ( g_pGameRules->ItemShouldRespawn( this ) )
{
Respawn();
}
else
{
UTIL_Remove(this);
}
return TRUE;
}
return FALSE;
}
//=========================================================
// Se activa cuando el usuario toca el objeto.
//=========================================================
bool CHealthKit::MyTouch(CBasePlayer *pPlayer)
{
// En modo Survival esto solo se puede usar desde el inventario.
if ( InGameRules()->IsSurvival() )
return false;
if ( pPlayer->TakeHealth(sk_healthkit.GetFloat(), DMG_GENERIC) )
{
CSingleUserRecipientFilter user(pPlayer);
user.MakeReliable();
UserMessageBegin(user, "ItemPickup");
WRITE_STRING(GetClassname());
MessageEnd();
CPASAttenuationFilter filter(pPlayer, "HealthKit.Touch");
EmitSound(filter, pPlayer->entindex(), "HealthKit.Touch");
if ( g_pGameRules->ItemShouldRespawn(this) )
Respawn();
else
Remove();
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Touch function that calls the virtual touch function
//-----------------------------------------------------------------------------
void CItem::ItemTouch( CBaseEntity *pOther )
{
// if it's not a player, ignore
if ( !pOther->IsPlayer() )
{
return;
}
CBasePlayer *pPlayer = (CBasePlayer *)pOther;
// ok, a player is touching this item, but can he have it?
if ( !g_pGameRules->CanHaveItem( pPlayer, this ) )
{
// no? Ignore the touch.
return;
}
if (MyTouch( pPlayer ))
{
SUB_UseTargets( pOther, USE_TOGGLE, 0 );
SetTouch( NULL );
// player grabbed the item.
g_pGameRules->PlayerGotItem( pPlayer, this );
if ( g_pGameRules->ItemShouldRespawn( this ) == GR_ITEM_RESPAWN_YES )
{
Respawn(m_flRespawnTime);
}
else
{
UTIL_Remove( this );
}
}
}
void CBasePlayerAmmo :: DefaultTouch( CBaseEntity *pOther )
{
if ( !pOther->IsPlayer() )
{
return;
}
if (AddAmmo( pOther ))
{
if ( g_pGameRules->AmmoShouldRespawn( this ) == GR_AMMO_RESPAWN_YES )
{
Respawn();
}
else
{
SetTouch( NULL );
SetThink(SUB_Remove);
pev->nextthink = gpGlobals->time + .1;
}
}
else if (gEvilImpulse101)
{
// evil impulse 101 hack, kill always
SetTouch( NULL );
SetThink(SUB_Remove);
pev->nextthink = gpGlobals->time + .1;
}
}
void CItem::ItemTouch( CBaseEntity *pOther )
{
//removed this limitation for monsters
if ( !pOther->IsPlayer() ) return;
CBasePlayer *pPlayer = (CBasePlayer *)pOther;
if (!UTIL_IsMasterTriggered(m_sMaster, pPlayer)) return;
if (pPlayer->pev->deadflag != DEAD_NO) return;
if (AddItem( pPlayer ) != -1 )
{
UTIL_FireTargets( pev->target, pOther, this, USE_TOGGLE );
SetTouch( NULL );
if( IsItem() && gmsg.ItemPickup )
{
//show icon for item
MESSAGE_BEGIN( MSG_ONE, gmsg.ItemPickup, NULL, pPlayer->pev );
WRITE_STRING( STRING(pev->classname) );
MESSAGE_END();
}
// play pickup sound
EMIT_SOUND( pPlayer->edict(), CHAN_ITEM, (char *)PickSound(), 1, ATTN_NORM );
// tell the owner item was taken
if (!FNullEnt( pev->owner )) pev->owner->v.impulse = 0;
// enable respawn in multiplayer
if ( g_pGameRules->IsMultiplayer() && !FBitSet( pev->spawnflags, SF_NORESPAWN ))
Respawn();
else UTIL_Remove( this );
}
else if ( gEvilImpulse101 ) UTIL_Remove( this );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPlayer -
// Output :
//-----------------------------------------------------------------------------
bool CHealthKit::MyTouch( CBasePlayer *pPlayer )
{
if ( pPlayer->TakeHealth( sk_healthkit.GetFloat(), DMG_GENERIC ) )
{
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "ItemPickup" );
WRITE_STRING( GetClassname() );
MessageEnd();
CPASAttenuationFilter filter( pPlayer, "HealthKit.Touch" );
EmitSound( filter, pPlayer->entindex(), "HealthKit.Touch" );
if ( g_pGameRules->ItemShouldRespawn( this ) )
{
Respawn();
}
else
{
UTIL_Remove(this);
}
return true;
}
return false;
}
//=========================================================
// Se activa cuando el usuario toca el objeto.
//=========================================================
bool CSoda::MyTouch(CBasePlayer *pPlayer)
{
// En modo Survival esto solo se puede usar desde el inventario.
if ( g_pGameRules->IsMultiplayer() )
return false;
CIN_Player *pInPlayer = GetInPlayer(pPlayer);
if ( !pPlayer )
return false;
if ( pInPlayer->TakeThirst(sk_soda.GetFloat()) != 0 )
{
CSingleUserRecipientFilter user(pInPlayer);
user.MakeReliable();
UserMessageBegin(user, "ItemPickup");
WRITE_STRING(GetClassname());
MessageEnd();
CPASAttenuationFilter filter(pInPlayer, "Player.Drink");
EmitSound(filter, entindex(), "Player.Drink");
if ( g_pGameRules->ItemShouldRespawn(this) )
Respawn();
else
Remove();
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Touch function that calls the virtual touch function
//-----------------------------------------------------------------------------
void CQuakeItem::ItemTouch( CBaseEntity *pOther )
{
// if it's not a player, ignore
if ( !pOther->IsPlayer() )
return;
//Dead?
if (pOther->pev->health <= 0)
return;
CBasePlayer *pPlayer = (CBasePlayer *)pOther;
// Call the virtual touch function
if ( MyTouch( pPlayer ) )
{
SUB_UseTargets( pOther, USE_TOGGLE, 0 );
// Respawn if it's not DM==2
if (gpGlobals->deathmatch != 2)
{
Respawn( m_flRespawnTime );
}
else
{
UTIL_Remove( this );
}
}
}
void CVehicle::Process(float fElapsedTime)
{
CPlayerPool* pPlayerPool = pNetGame->GetPlayerPool();
// Check for an idle vehicle.. but don't do this
// every ::Process because it would be too CPU intensive.
if(!m_bDeathHasBeenNotified && m_SpawnInfo.iRespawnDelay != (-1) && ((rand() % 20) == 0)) {
CheckForIdleRespawn();
return;
}
// we'll check for a dead vehicle.
if(m_bDead)
{
if (!m_bDeathHasBeenNotified)
{
m_bDeathHasBeenNotified = true;
m_szNumberPlate[0] = 0;
if(pNetGame->GetGameMode() && pNetGame->GetFilterScripts()) {
pNetGame->GetFilterScripts()->OnVehicleDeath(m_VehicleID, 255);
pNetGame->GetGameMode()->OnVehicleDeath(m_VehicleID, 255);
}
m_dwLastSeenOccupiedTick = GetTickCount();
}
if(!(rand() % 20) && GetTickCount() - m_dwLastSeenOccupiedTick > 10000)
{
Respawn();
}
}
}
void Player::OnBombCollision()
{
if (m_canBeDamaged)
{
Respawn();
}
}
void PlayerVehicle::SetRidden(bool bRidden)
{
if (bRidden)
{
g_pCommonLT->GetObjectFlags(m_hObject, OFT_Flags, m_dwSavedFlags);
bool bRH = !!(m_dwSavedFlags & FLAG_RAYHIT);
// Remove flags that cause the vehicle to go through extensive moveobjects. It will
// reset its own flags under the respawn.
g_pCommonLT->SetObjectFlags(m_hObject, OFT_Flags, FLAG_FORCEOPTIMIZEOBJECT, FLAG_GRAVITY | FLAG_SOLID | FLAG_RAYHIT | FLAG_TOUCH_NOTIFY | FLAG_FORCEOPTIMIZEOBJECT);
g_pCommonLT->SetObjectFlags(m_hObject, OFT_User, USRFLG_ATTACH_HIDE1SHOW3, USRFLG_ATTACH_HIDE1SHOW3);
// We have now been ridden.
m_bVirgin = false;
}
else
{
g_pCommonLT->SetObjectFlags(m_hObject, OFT_User, 0, USRFLG_ATTACH_HIDE1SHOW3);
g_pCommonLT->SetObjectFlags(m_hObject, OFT_Flags, m_dwSavedFlags, FLAGMASK_ALL);
uint32 dwFlags;
g_pCommonLT->GetObjectFlags(m_hObject, OFT_Flags, dwFlags);
bool bRH = !!(dwFlags & FLAG_RAYHIT);
// Record the last time this vehicle has been ridden.
m_fLastRideTime = g_pLTServer->GetTime( );
Respawn();
}
m_bRidden = bRidden;
}
void CBasePlayerAmmo :: DefaultTouch( CBaseEntity *pOther )
{
if ( !pOther->IsPlayer() )
{
return;
}
if (!UTIL_IsMasterTriggered(m_sMaster, m_pPlayer)) //
return ; // AJH allows for locked weapons
if (AddAmmo( pOther ))
{
if ( g_pGameRules->AmmoShouldRespawn( this ) == GR_AMMO_RESPAWN_YES )
{
Respawn();
}
else
{
SetTouch( NULL );
SetThink(&CBasePlayerAmmo ::SUB_Remove);
SetNextThink( 0.1 );
}
SUB_UseTargets( pOther, USE_TOGGLE, 0 ); //AJH now ammo can trigger stuff too
}
else if (gEvilImpulse101)
{
// evil impulse 101 hack, kill always
SetTouch( NULL );
SetThink(&CBasePlayerAmmo ::SUB_Remove);
SetNextThink( 0.1 );
}
}
void Player::OnKeyDown(const CL_InputEvent &key, const CL_InputState &state)
{
if (m_flags[eDead]) {
//TODO: I was a bit lazy here, maybe introduce respawn key as a keybind?
if (key.id == CL_KEY_F1) {
Respawn();
}
return;
}
//TODO: can this be turned into a switch-case without breaking logic?
if (key.id == m_moveLeftKey) {
m_moveLeftKeyPressed = true;
StartMoving(eLeft);
}
if (key.id == m_moveRightKey) {
m_moveRightKeyPressed = true;
StartMoving(eRight);
}
if (key.id == m_jumpKey && !m_jumpKeyPressed) {
m_jumpKeyPressed = true;
StartJump();
}
if (key.id == m_attackKey && !m_attackKeyPressed) {
m_attackKeyPressed = true;
StartAttack();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pOther -
//-----------------------------------------------------------------------------
void CItem::ItemTouch( CBaseEntity *pOther )
{
// Vehicles can touch items + pick them up
if ( pOther->GetServerVehicle() )
{
pOther = pOther->GetServerVehicle()->GetPassenger();
if ( !pOther )
return;
}
// if it's not a player, ignore
if ( !pOther->IsPlayer() )
return;
CBasePlayer *pPlayer = (CBasePlayer *)pOther;
// Must be a valid pickup scenario (no blocking). Though this is a more expensive
// check than some that follow, this has to be first Obecause it's the only one
// that inhibits firing the output OnCacheInteraction.
if ( ItemCanBeTouchedByPlayer( pPlayer ) == false )
return;
m_OnCacheInteraction.FireOutput(pOther, this);
// Can I even pick stuff up?
if ( !pPlayer->IsAllowedToPickupWeapons() )
return;
// ok, a player is touching this item, but can he have it?
if ( !g_pGameRules->CanHaveItem( pPlayer, this ) )
{
// no? Ignore the touch.
return;
}
if ( MyTouch( pPlayer ) )
{
m_OnPlayerTouch.FireOutput(pOther, this);
SetTouch( NULL );
SetThink( NULL );
// player grabbed the item.
g_pGameRules->PlayerGotItem( pPlayer, this );
if ( g_pGameRules->ItemShouldRespawn( this ) == GR_ITEM_RESPAWN_YES )
{
Respawn();
}
else
{
UTIL_Remove( this );
}
}
else if (gEvilImpulse101)
{
UTIL_Remove( this );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pOther -
//-----------------------------------------------------------------------------
void CItem::ItemTouch( CBaseEntity *pOther )
{
// Vehicles can touch items + pick them up
if ( pOther->GetServerVehicle() )
{
pOther = pOther->GetServerVehicle()->GetPassenger();
if ( !pOther )
return;
}
// if it's not a player, ignore
if ( !pOther->IsPlayer() )
return;
// Can I even pick stuff up?
if ( pOther->IsEFlagSet( EFL_NO_WEAPON_PICKUP ) )
return;
CBasePlayer *pPlayer = (CBasePlayer *)pOther;
// ok, a player is touching this item, but can he have it?
if ( !g_pGameRules->CanHaveItem( pPlayer, this ) )
{
// no? Ignore the touch.
return;
}
// Must be a valid pickup scenario (no blocking)
if ( ItemCanBeTouchedByPlayer( pPlayer ) == false )
return;
if ( MyTouch( pPlayer ) )
{
m_OnPlayerTouch.FireOutput(pOther, this);
SetTouch( NULL );
SetThink( NULL );
// player grabbed the item.
g_pGameRules->PlayerGotItem( pPlayer, this );
if ( g_pGameRules->ItemShouldRespawn( this ) == GR_ITEM_RESPAWN_YES )
{
Respawn();
}
else
{
UTIL_Remove( this );
#ifdef HL2MP
HL2MPRules()->RemoveLevelDesignerPlacedObject( this );
#endif
}
}
else if (gEvilImpulse101)
{
UTIL_Remove( this );
}
}
void ABasicBuff::AdvanceRespawnTimer()
{
RespawnTime--;
if (RespawnTime < 1)
{
GetWorldTimerManager().ClearTimer(RespawnTimerHandle);
Respawn();
}
}
void AInGame_PlayerController::AdvanceRespawnTimer()
{
RespawnTimer--;
if (RespawnTimer < 1)
{
Respawn();
RespawnTimer = RespawnTime;
GetWorldTimerManager().ClearTimer(DeathHandle);
}
}
void AProjectTapGameMode::OnCameraFaded()
{
switch(lastReportedState)
{
case CustomGameState::GAME_STATE_GAME_OVER:
Respawn();
break;
case CustomGameState::GAME_STATE_WIN:
LoadNextLevel();
}
}
void CLauncherService::SignalCatcher(int nSignal)
{
pid_t pid;
int nReturn;
if (nSignal != SIGCHLD)
return;
pid = waitpid(-1, &nReturn, WNOHANG);
if (pid > 0)
Respawn(pid);
}
//=========================================================
// CheckRespawn - a player is taking this weapon, should
// it respawn?
//=========================================================
void CBasePlayerItem :: CheckRespawn ( void )
{
switch ( g_pGameRules->WeaponShouldRespawn( this ) )
{
case GR_WEAPON_RESPAWN_YES:
Respawn();
break;
case GR_WEAPON_RESPAWN_NO:
return;
break;
}
}
void Ammo::Update(float elapsed) {
if (spawnDelay > -1) {
spawnDelay--;
}
if (spawnDelay == 0) {
Respawn();
}
sprite.index += animSpeed;
if (sprite.index > animEnd + 1) {
sprite.index = animStart;
}
}
LTBOOL PickupItem::Update()
{
SetNextUpdate(UPDATE_NEVER);
// If we aren't visible it must be time to respawn...
if( m_bWasPickedUp )
{
Respawn( );
m_bWasPickedUp = false;
}
return LTTRUE;
}
void Pickup::HandleTriggerStart(StringHash eventType, VariantMap &eventData)
{
PODVector<RigidBody*> collidingBodies;
triggerBody_->GetCollidingBodies(collidingBodies);
for (int i = 0; i < collidingBodies.Size(); i++) {
RigidBody* collider = collidingBodies[i];
if (collider->GetNode()->GetNameHash() == N_PLAYER) {
masterControl_->player_->Pickup(pickupType_);
masterControl_->spawnMaster_->SpawnHitFX(GetPosition(), false);
switch (pickupType_){
case PT_MULTIX: case PT_CHAOBALL: Deactivate(); break;
case PT_APPLE: case PT_HEART: Respawn(); break;
default: break;
}
}
}
}
void CAsteroid::Update( float fTime )
{
if ( m_fInvincibleTime > 0.0f )
m_pExplosionParticle->UpdateFrame( fTime );
if(m_fBounceToggleTime > 0.0001f){
m_fBounceToggleTime -= fTime;
}
if(m_fRespawnTime > 0.0f) // Still respawning
{
m_fRespawnTime -= fTime;
if(m_fRespawnTime < 0.0f) m_bIsGrabable = true; // Timer over, grabable
if(m_fRespawnTime < 1.0f && m_fRespawnTime + fTime > 1.0f)
Respawn(); // Respawn at 1 seconds mark
}
if(!m_bTempChangedThisFrame && m_eAsteroidState == NORMAL && m_fTemperatureTime != 0.0f)
{
float newTemp = m_fTemperatureTime + (m_fTemperatureTime > 0.0f ? -fTime : fTime);
if(newTemp * m_fTemperatureTime < 0.0f) // Changed sign
m_fTemperatureTime = 0.0f;
else
m_fTemperatureTime = newTemp;
}
m_bTempChangedThisFrame = false; // Set false for next frame
if(m_fTemperatureTime <= -m_fTempTime && m_eAsteroidState != FROZEN)
{
m_eAsteroidState = FROZEN;
}
else if(m_fTemperatureTime > -m_fTempTime && m_fTemperatureTime < m_fTempTime && m_eAsteroidState != NORMAL)
{
m_eAsteroidState = NORMAL;
}
else if(m_fTemperatureTime >= m_fTempTime && m_eAsteroidState != ON_FIRE)
{
m_eAsteroidState = ON_FIRE;
}
CPlanet::Update( fTime );
}
void CVehicle::CheckForIdleRespawn()
{
// can't respawn an idle train or train part
if(IsATrainPart()) return;
if( (GetTickCount() - m_dwLastRespawnedTick) < 10000 ) {
// We should wait at least 10 seconds after the last
// respawn before checking. Come back later.
return;
}
if(!IsOccupied()) {
if( m_bHasBeenOccupied &&
(GetTickCount() - m_dwLastSeenOccupiedTick) >= (DWORD)m_SpawnInfo.iRespawnDelay ) {
//printf("Respawning idle vehicle %u\n",m_VehicleID);
Respawn();
}
}
}
void Pickup::HandleSceneUpdate(StringHash eventType, VariantMap& eventData)
{
float timeStep = eventData[Update::P_TIMESTEP].GetFloat();
//Move trigger along
triggerNode_->SetPosition(rootNode_->GetPosition());
//Emerge
if (!IsEmerged()) {
rigidBody_->ResetForces();
rigidBody_->SetLinearVelocity(Vector3::ZERO);
rootNode_->Translate(Vector3::UP * timeStep * (0.23f - rootNode_->GetPosition().y_), TS_WORLD);
}
float xSpin = 0.0f;
float ySpin = 100.0f;
float zSpin = 0.0f;
float frequency = 2.5f;
float shift = 0.5f;
switch (pickupType_){
case PT_APPLE: shift = 0.23f; break;
case PT_HEART: break;
case PT_MULTIX:
xSpin = 64.0f; zSpin = 10.0f; frequency = 5.0f;
if (IsEmerged() && masterControl_->GetGameState() == GS_PLAY)
rigidBody_->ApplyForce(2.0f*masterControl_->player_->GetPosition() - rigidBody_->GetLinearVelocity()); break;
case PT_CHAOBALL: {
xSpin = 23.0f; zSpin = 42.0f; frequency = 5.0f; shift = 0.23f;
if (!rootNode_->IsEnabled() && masterControl_->GetGameState() == GS_PLAY) {
if (sinceLastPickup_ > chaoInterval_) Respawn();
else sinceLastPickup_ += timeStep;
}
else if (IsEmerged() && masterControl_->GetGameState() == GS_PLAY)
rigidBody_->ApplyForce(-3.0f*masterControl_->player_->GetPosition() - rigidBody_->GetLinearVelocity()); break;
} break;
default: break;
}
//Spin
rootNode_->Rotate(Quaternion(xSpin * timeStep, ySpin * timeStep, zSpin * timeStep));
//Float like a float
float floatFactor = 0.5f - Min(0.5f, 0.5f * Abs(rootNode_->GetPosition().y_));
graphicsNode_->SetPosition(Vector3::UP * masterControl_->Sine(frequency, -floatFactor, floatFactor, shift));
}
bool CArmor::MyTouch( CBasePlayer *pPlayer )
{
if ( SetArmor(pPlayer) )
{
CSingleUserRecipientFilter user( pPlayer );
user.MakeReliable();
UserMessageBegin( user, "ItemPickup" );
WRITE_STRING( GetClassname() );
MessageEnd();
if(Q_strcmp(this->GetClassname(), "item_armor_small") == 0)
{
CPASAttenuationFilter filter( pPlayer, "Armor_Small.Touch" );
EmitSound( filter, pPlayer->entindex(), "Armor_Small.Touch" );
}
else if(Q_strcmp(this->GetClassname(), "item_armor_medium") == 0)
{
CPASAttenuationFilter filter( pPlayer, "Armor_Medium.Touch" );
EmitSound( filter, pPlayer->entindex(), "Armor_Medium.Touch" );
}
else
{
CPASAttenuationFilter filter( pPlayer, "Armor_Large.Touch" );
EmitSound( filter, pPlayer->entindex(), "Armor_Large.Touch" );
}
if ( g_pGameRules->ItemShouldRespawn( this ) )
{
Respawn();
}
else
{
UTIL_Remove(this);
}
return true;
}
return false;
}
// Called from CItem::ItemTouch()
bool CRotatingPickup::MyTouch( CBasePlayer *pPlayer )
{
if ( pPlayer && pPlayer->GetHealth() < pPlayer->GetMaxHealth() )
{
pPlayer->TakeHealth( m_iHealthToGive, DMG_GENERIC );
CSingleUserRecipientFilter PlayerFilter( pPlayer );
PlayerFilter.MakeReliable();
UserMessageBegin( PlayerFilter, "ItemPickup" );
WRITE_STRING( GetClassname() );
MessageEnd();
EmitSound( PlayerFilter, pPlayer->entindex(), "HealthKit.Touch" ); // this should be done by the HUD really
Respawn();
return true;
}
return false;
}
void CPlayer::OnDirectInput(CNetObj_PlayerInput *NewInput)
{
if(GameServer()->m_World.m_Paused)
{
m_PlayerFlags = NewInput->m_PlayerFlags;
return;
}
if(NewInput->m_PlayerFlags&PLAYERFLAG_CHATTING)
{
// skip the input if chat is active
if(m_PlayerFlags&PLAYERFLAG_CHATTING)
return;
// reset input
if(m_pCharacter)
m_pCharacter->ResetInput();
m_PlayerFlags = NewInput->m_PlayerFlags;
return;
}
m_PlayerFlags = NewInput->m_PlayerFlags;
if(m_pCharacter)
m_pCharacter->OnDirectInput(NewInput);
if(!m_pCharacter && m_Team != TEAM_SPECTATORS && (NewInput->m_Fire&1))
Respawn();
// check for activity
if(NewInput->m_Direction || m_LatestActivity.m_TargetX != NewInput->m_TargetX ||
m_LatestActivity.m_TargetY != NewInput->m_TargetY || NewInput->m_Jump ||
NewInput->m_Fire&1 || NewInput->m_Hook)
{
m_LatestActivity.m_TargetX = NewInput->m_TargetX;
m_LatestActivity.m_TargetY = NewInput->m_TargetY;
m_LastActionTick = Server()->Tick();
m_InactivityTickCounter = 0;
}
}
