// resets all entities that need reseting
void CBaseRoundRules::ResetWorld(bool bResetCustom, bool bResetOnlyCustom)
{
if(bResetOnlyCustom == false) {
// - breakables
CBreakable * pBreakable = NULL;
pBreakable = (CBreakable*)UTIL_FindEntityByClassname( pBreakable, "func_breakable" );
while (pBreakable)
{
pBreakable->Reset();
pBreakable = (CBreakable*)UTIL_FindEntityByClassname( pBreakable, "func_breakable" );
}
// - doors
CBaseDoor *pDoor = NULL;
pDoor = (CBaseDoor*)UTIL_FindEntityByClassname( pBreakable, "func_door" );
while (pBreakable)
{
pDoor->Spawn();
pDoor->SUB_UseTargets(pDoor, USE_OFF, 0.0);
pDoor = (CBaseDoor*)UTIL_FindEntityByClassname( pDoor, "func_door" );
}
// - points
pPointManager->ResetAllPoints();
pPointManager->UpdatePlayersHUD();
// - spawn containers
g_pBGRules->InitSpawns();
}
if(bResetCustom == true) {
g_pBGRules->InitSpawns();
// -reseter ent
CBaseEntity *pResetEnt = NULL;
pResetEnt = (CBaseEntity*)UTIL_FindEntityByClassname( pResetEnt, "info_reset" );
// -this allows us to reset the ents the mapper wants
// -ben : I didn't want to do this but this could solve some bh probs
CountPlayersOnTeam(true);
if(GetNumOfBritishPlayers() <= 0 || GetNumOfAmericanPlayers() <= 0)
return;
while (pResetEnt)
{
pResetEnt->ResetEnt();
pResetEnt = (CBaseEntity*)UTIL_FindEntityByClassname( pResetEnt, "info_reset" );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Passes Touch along to certain named doors.
//-----------------------------------------------------------------------------
void CBaseDoor::ChainTouch( CBaseEntity *pOther )
{
if ( m_isChaining )
return;
CBaseEntity *ent = NULL;
while ( ( ent = gEntList.FindEntityByName( ent, m_ChainTarget, NULL ) ) != NULL )
{
if ( ent == this )
continue;
CBaseDoor *door = dynamic_cast< CBaseDoor * >( ent );
if ( door )
{
door->SetChaining( true );
door->Touch( pOther );
door->SetChaining( false );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Passes Use along to certain named doors.
//-----------------------------------------------------------------------------
void CBaseDoor::ChainUse( void )
{
if ( m_isChaining )
return;
CBaseEntity *ent = NULL;
while ( ( ent = gEntList.FindEntityByName( ent, m_ChainTarget, NULL ) ) != NULL )
{
if ( ent == this )
continue;
CBaseDoor *door = dynamic_cast< CBaseDoor * >( ent );
if ( door )
{
door->SetChaining( true );
door->Use( m_hActivator, NULL, USE_TOGGLE, 0.0f ); // only the first param is used
door->SetChaining( false );
}
}
}
void CBaseDoor :: ChainTouch( CBaseEntity *pOther )
{
// to prevent recursion
if( m_isChaining ) return;
CBaseEntity *pEnt = NULL;
while(( pEnt = UTIL_FindEntityByTargetname( pEnt, STRING( m_iChainTarget ))) != NULL )
{
if( pEnt == this ) continue;
CBaseDoor *pDoor = (CBaseDoor *)pEnt;
if( pDoor )
{
pDoor->SetChaining( true );
pDoor->Touch( pOther );
pDoor->SetChaining( false );
}
}
}
void CBaseDoor :: ChainUse( USE_TYPE useType, float value )
{
// to prevent recursion
if( m_isChaining ) return;
CBaseEntity *pEnt = NULL;
while(( pEnt = UTIL_FindEntityByTargetname( pEnt, STRING( m_iChainTarget ))) != NULL )
{
if( pEnt == this ) continue;
CBaseDoor *pDoor = (CBaseDoor *)pEnt;
if( pDoor )
{
pDoor->SetChaining( true );
pDoor->Use( m_hActivator, this, useType, value );
pDoor->SetChaining( false );
}
}
}
void CBaseDoor::Blocked( CBaseEntity *pOther )
{
// hurt the blocker a little.
if( pev->dmg ) pOther->TakeDamage( pev, pev, pev->dmg, DMG_CRUSH );
// if a door has a negative wait, it would never come back if blocked,
// so let it just squash the object to death real fast
if( m_flWait >= 0 )
{
if( !FBitSet( pev->spawnflags, SF_DOOR_SILENT ))
STOP_SOUND( edict(), CHAN_STATIC, STRING( pev->noise1 ));
if( m_iState == STATE_TURN_OFF )
{
DoorGoUp();
}
else
{
DoorGoDown();
}
}
// block all door pieces with the same targetname here.
if( !FStringNull( pev->targetname ))
{
CBaseDoor *pDoorList[64];
int doorCount = GetDoorMovementGroup( pDoorList, ARRAYSIZE( pDoorList ));
for( int i = 0; i < doorCount; i++ )
{
CBaseDoor *pDoor = pDoorList[i];
if( pDoor->m_flWait >= 0)
{
if( m_bDoorGroup && pDoor->pev->movedir == pev->movedir && pDoor->GetAbsVelocity() == GetAbsVelocity() && pDoor->GetLocalAvelocity() == GetLocalAvelocity( ))
{
pDoor->m_iPhysicsFrame = g_ulFrameCount; // don't run physics this frame if you haven't run yet
// this is the most hacked, evil, bastardized thing I've ever seen. kjb
if( !pDoor->IsRotatingDoor( ))
{
// set origin to realign normal doors
pDoor->SetLocalOrigin( GetLocalOrigin( ));
pDoor->SetAbsVelocity( g_vecZero ); // stop!
}
else
{
// set angles to realign rotating doors
pDoor->SetLocalAngles( GetLocalAngles( ));
pDoor->SetLocalAvelocity( g_vecZero );
}
}
if( pDoor->m_iState == STATE_TURN_OFF )
pDoor->DoorGoUp();
else pDoor->DoorGoDown();
}
}
}
}
void CBaseDoor::Blocked( CBaseEntity *pOther )
{
edict_t *pentTarget = NULL;
CBaseDoor *pDoor = NULL;
// Hurt the blocker a little.
if ( pev->dmg )
pOther->TakeDamage( pev, pev, pev->dmg, DMG_CRUSH );
// if a door has a negative wait, it would never come back if blocked,
// so let it just squash the object to death real fast
if (m_flWait >= 0)
{
if (m_toggle_state == TS_GOING_DOWN)
{
DoorGoUp();
}
else
{
DoorGoDown();
}
}
// Block all door pieces with the same targetname here.
if ( !FStringNull ( pev->targetname ) )
{
for (;;)
{
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(pev->targetname));
if ( VARS( pentTarget ) != pev )
{
if (FNullEnt(pentTarget))
break;
if ( FClassnameIs ( pentTarget, "func_door" ) || FClassnameIs ( pentTarget, "func_door_rotating" ) )
{
pDoor = GetClassPtr( (CBaseDoor *) VARS(pentTarget) );
if ( pDoor->m_flWait >= 0)
{
if (pDoor->pev->velocity == pev->velocity && pDoor->pev->avelocity == pev->velocity)
{
// this is the most hacked, evil, bastardized thing I've ever seen. kjb
if ( FClassnameIs ( pentTarget, "func_door" ) )
{// set origin to realign normal doors
pDoor->pev->origin = pev->origin;
pDoor->pev->velocity = g_vecZero;// stop!
}
else
{// set angles to realign rotating doors
pDoor->pev->angles = pev->angles;
pDoor->pev->avelocity = g_vecZero;
}
}
if ( pDoor->m_toggle_state == TS_GOING_DOWN)
pDoor->DoorGoUp();
else
pDoor->DoorGoDown();
}
}
}
}
}
}
/* <6a465> ../cstrike/dlls/doors.cpp:817 */
void CBaseDoor::__MAKE_VHOOK(Blocked)(CBaseEntity *pOther)
{
edict_t *pentTarget = NULL;
CBaseDoor *pDoor = NULL;
const float checkBlockedInterval = 0.25f;
// Hurt the blocker a little.
if (pev->dmg != 0.0f)
{
pOther->TakeDamage(pev, pev, pev->dmg, DMG_CRUSH);
}
if (gpGlobals->time - m_lastBlockedTimestamp < checkBlockedInterval)
{
return;
}
m_lastBlockedTimestamp = gpGlobals->time;
// if a door has a negative wait, it would never come back if blocked,
// so let it just squash the object to death real fast
if (m_flWait >= 0)
{
if (m_toggle_state == TS_GOING_DOWN)
{
DoorGoUp();
}
else
{
DoorGoDown();
}
}
// Block all door pieces with the same targetname here.
if (!FStringNull(pev->targetname))
{
while (true)
{
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(pev->targetname));
if (VARS(pentTarget) != pev)
{
if (FNullEnt(pentTarget))
break;
if (FClassnameIs(pentTarget, "func_door") || FClassnameIs(pentTarget, "func_door_rotating"))
{
pDoor = GetClassPtr((CBaseDoor *)VARS(pentTarget));
if (pDoor->m_flWait >= 0)
{
if (pDoor->pev->velocity == pev->velocity && pDoor->pev->avelocity == pev->velocity)
{
// this is the most hacked, evil, bastardized thing I've ever seen. kjb
if (FClassnameIs(pentTarget, "func_door"))
{
// set origin to realign normal doors
pDoor->pev->origin = pev->origin;
// stop!
pDoor->pev->velocity = g_vecZero;
}
else
{
// set angles to realign rotating doors
pDoor->pev->angles = pev->angles;
pDoor->pev->avelocity = g_vecZero;
}
}
if (!(pev->spawnflags & SF_DOOR_SILENT))
{
STOP_SOUND(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseMoving));
}
if (pDoor->m_toggle_state == TS_GOING_DOWN)
pDoor->DoorGoUp();
else
pDoor->DoorGoDown();
}
}
}
}
}
}
void CBaseDoor::Blocked( CBaseEntity *pOther )
{
CBaseEntity *pTarget = NULL;
CBaseDoor *pDoor = NULL;
// ALERT(at_debug, "%s blocked\n", STRING(pev->targetname));
// Hurt the blocker a little.
if ( pev->dmg )
if (m_hActivator)
pOther->TakeDamage( pev, m_hActivator->pev, pev->dmg, DMG_CRUSH ); //AJH Attribute damage to he who switched me.
else
pOther->TakeDamage( pev, pev, pev->dmg, DMG_CRUSH );
// if a door has a negative wait, it would never come back if blocked,
// so let it just squash the object to death real fast
if (m_flWait >= 0)
{
//LRC - thanks to [insert name here] for this
if ( !FBitSet( pev->spawnflags, SF_DOOR_SILENT ) )
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMoving) );
if (m_toggle_state == TS_GOING_DOWN)
{
DoorGoUp();
}
else
{
DoorGoDown();
}
}
// Block all door pieces with the same targetname here.
//LRC - in immediate mode don't do this, doors are expected to do it themselves.
if ( !m_iImmediateMode && !FStringNull ( pev->targetname ) )
{
for (;;)
{
pTarget = UTIL_FindEntityByTargetname(pTarget, STRING(pev->targetname));
if ( !pTarget )
break;
if ( VARS( pTarget->pev ) != pev && FClassnameIs ( pTarget->pev, "func_door" ) ||
FClassnameIs ( pTarget->pev, "func_door_rotating" ) )
{
pDoor = GetClassPtr( (CBaseDoor *) VARS(pTarget->pev) );
if ( pDoor->m_flWait >= 0)
{
// avelocity == velocity!? LRC
if (pDoor->pev->velocity == pev->velocity && pDoor->pev->avelocity == pev->velocity)
{
// this is the most hacked, evil, bastardized thing I've ever seen. kjb
if ( FClassnameIs ( pTarget->pev, "func_door" ) )
{// set origin to realign normal doors
pDoor->pev->origin = pev->origin;
UTIL_SetVelocity(pDoor, g_vecZero);// stop!
}
else
{// set angles to realign rotating doors
pDoor->pev->angles = pev->angles;
UTIL_SetAvelocity(pDoor, g_vecZero);
}
}
if ( pDoor->m_toggle_state == TS_GOING_DOWN)
pDoor->DoorGoUp();
else
pDoor->DoorGoDown();
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Called every frame when the door is blocked while opening or closing.
// Input : pOther - The blocking entity.
//-----------------------------------------------------------------------------
void CBaseDoor::Blocked( CBaseEntity *pOther )
{
// Hurt the blocker a little.
if ( m_flBlockDamage )
{
// if the door is marked "force closed" or it has a negative wait, then there's nothing to do but
// push/damage the object.
// If block damage is set, but this object is a physics prop that can't be damaged, just
// give up and disable collisions
if ( (m_bForceClosed || m_flWait < 0) && pOther->GetMoveType() == MOVETYPE_VPHYSICS &&
(pOther->m_takedamage == DAMAGE_NO || pOther->m_takedamage == DAMAGE_EVENTS_ONLY) )
{
EntityPhysics_CreateSolver( this, pOther, true, 4.0f );
}
else
{
pOther->TakeDamage( CTakeDamageInfo( this, this, m_flBlockDamage, DMG_CRUSH ) );
}
}
// If we're set to force ourselves closed, keep going
if ( m_bForceClosed )
return;
// if a door has a negative wait, it would never come back if blocked,
// so let it just squash the object to death real fast
if (m_flWait >= 0)
{
if (m_toggle_state == TS_GOING_DOWN)
{
DoorGoUp();
}
else
{
DoorGoDown();
}
}
// Block all door pieces with the same targetname here.
if ( GetEntityName() != NULL_STRING )
{
CBaseDoor *pDoorList[64];
int doorCount = GetDoorMovementGroup( pDoorList, ARRAYSIZE(pDoorList) );
for ( int i = 0; i < doorCount; i++ )
{
CBaseDoor *pDoor = pDoorList[i];
if ( pDoor->m_flWait >= 0)
{
if (m_bDoorGroup && pDoor->m_vecMoveDir == m_vecMoveDir && pDoor->GetAbsVelocity() == GetAbsVelocity() && pDoor->GetLocalAngularVelocity() == GetLocalAngularVelocity())
{
pDoor->m_nSimulationTick = m_nSimulationTick; // don't run simulation this frame if you haven't run yet
// this is the most hacked, evil, bastardized thing I've ever seen. kjb
if ( !pDoor->IsRotatingDoor() )
{// set origin to realign normal doors
pDoor->SetLocalOrigin( GetLocalOrigin() );
pDoor->SetAbsVelocity( vec3_origin );// stop!
}
else
{// set angles to realign rotating doors
pDoor->SetLocalAngles( GetLocalAngles() );
pDoor->SetLocalAngularVelocity( vec3_angle );
}
}
if ( pDoor->m_toggle_state == TS_GOING_DOWN)
pDoor->DoorGoUp();
else
pDoor->DoorGoDown();
}
}
}
}
void CBaseDoor::Blocked( CBaseEntity *pOther )
{
CBaseDoor *pDoor = NULL;
// Hurt the blocker a little.
if( GetDamage() )
pOther->TakeDamage( this, this, GetDamage(), DMG_CRUSH );
// if a door has a negative wait, it would never come back if blocked,
// so let it just squash the object to death real fast
if( m_flWait >= 0 )
{
if( m_toggle_state == TS_GOING_DOWN )
{
DoorGoUp();
}
else
{
DoorGoDown();
}
}
// Block all door pieces with the same targetname here.
if( HasTargetname() )
{
CBaseEntity* pTarget = nullptr;
while( ( pTarget = UTIL_FindEntityByTargetname( pTarget, GetTargetname() ) ) != nullptr )
{
if( pTarget != this )
{
if( pTarget->ClassnameIs( "func_door" ) || pTarget->ClassnameIs( "func_door_rotating" ) )
{
pDoor = static_cast<CBaseDoor*>( pTarget );
if( pDoor->m_flWait >= 0 )
{
//TODO: comparing avel with vel is probably wrong - Solokiller
if( pDoor->GetAbsVelocity() == GetAbsVelocity() && pDoor->GetAngularVelocity() == GetAbsVelocity() )
{
// this is the most hacked, evil, bastardized thing I've ever seen. kjb
if( pTarget->ClassnameIs( "func_door" ) )
{// set origin to realign normal doors
pDoor->SetAbsOrigin( GetAbsOrigin() );
pDoor->SetAbsVelocity( g_vecZero );// stop!
}
else
{// set angles to realign rotating doors
pDoor->SetAbsAngles( GetAbsAngles() );
pDoor->SetAngularVelocity( g_vecZero );
}
}
if( !GetSpawnFlags().Any( SF_DOOR_SILENT ) )
STOP_SOUND( this, CHAN_STATIC, ( char* ) STRING( pev->noiseMoving ) );
if( pDoor->m_toggle_state == TS_GOING_DOWN )
pDoor->DoorGoUp();
else
pDoor->DoorGoDown();
}
}
}
}
}
}
