//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTriggerAreaCapture::GetNumCappingPlayers( int team, int &numcappers, int *cappingplayers )
{
numcappers = 0;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBaseEntity *ent = UTIL_PlayerByIndex( i );
if ( ent )
{
CBaseMultiplayerPlayer *player = ToBaseMultiplayerPlayer(ent);
if ( IsTouching( player ) && ( player->GetTeamNumber() == team ) ) // need to make sure disguised spies aren't included in the list of capping players
{
if ( numcappers < MAX_AREA_CAPPERS-1 )
{
cappingplayers[numcappers] = i;
numcappers++;
}
}
}
}
if ( numcappers < MAX_AREA_CAPPERS )
{
cappingplayers[numcappers] = 0; //null terminate :)
}
}
void CTriggerLimitMovement::Think()
{
CMomentumPlayer *pPlayer = ToCMOMPlayer(UTIL_GetListenServerHost());
if (pPlayer && IsTouching(pPlayer))
{
if (HasSpawnFlags(LIMIT_BHOP))
{
pPlayer->DisableButtons(IN_JUMP);
// if player in air
if (pPlayer->GetGroundEntity() != nullptr)
{
// only start timer if we havent already started
if (!m_BhopTimer.HasStarted())
m_BhopTimer.Start(FL_BHOP_TIMER);
// when finished
if (m_BhopTimer.IsElapsed())
{
pPlayer->EnableButtons(IN_JUMP);
m_BhopTimer.Reset();
}
}
}
}
// figure out if timer elapsed or not
if (m_BhopTimer.GetRemainingTime() <= 0)
m_BhopTimer.Invalidate();
// DevLog("Bhop Timer Remaining Time:%f\n", m_BhopTimer.GetRemainingTime());
// HACKHACK - this prevents think from running too fast, breaking the timer
// and preventing the player from jumping until the timer runs out
// Thinking every 0.25 seconds seems to feel good, but we can adjust this later
SetNextThink(gpGlobals->curtime + 0.25);
BaseClass::Think();
}
void CTriggerUserInput::Think()
{
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
if (pPlayer != NULL && IsTouching(pPlayer) && (pPlayer->m_nButtons & m_ButtonRep))
{
m_OnKeyPressed.FireOutput(pPlayer, this);
}
BaseClass::Think();
}
//-----------------------------------------------------------------------------
// Purpose: Called when an entity stops touching us.
// Input : pOther - The entity that was touching us.
//-----------------------------------------------------------------------------
void CTriggerWeaponStrip::EndTouch(CBaseEntity *pOther)
{
if ( IsTouching( pOther ) )
{
pOther->RemoveEFlags( EFL_NO_WEAPON_PICKUP );
}
BaseClass::EndTouch( pOther );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTriggerAreaCapture::BreakCapture( bool bNotEnoughPlayers )
{
if( m_bCapturing )
{
// Remap team to get first game team = 1
switch ( m_nCapturingTeam - FIRST_GAME_TEAM+1 )
{
case 1:
m_OnBreakTeam1.FireOutput( this, this );
break;
case 2:
m_OnBreakTeam2.FireOutput( this, this );
break;
default:
Assert(0);
break;
}
m_BreakOutput.FireOutput(this,this);
m_bCapturing = false;
m_nCapturingTeam = TEAM_UNASSIGNED;
UpdateCappingTeam( TEAM_UNASSIGNED );
if ( bNotEnoughPlayers )
{
IncrementCapAttemptNumber();
}
SetCapTimeRemaining( 0 );
if( m_hPoint )
{
m_hPoint->CaptureEnd();
}
m_OnNumCappersChanged.Set( 0, this, this );
// tell all touching players to stop racking up capture points
CTeam *pTeam = GetGlobalTeam( m_nCapturingTeam );
if ( pTeam )
{
for ( int i=0;i<pTeam->GetNumPlayers();i++ )
{
CBaseMultiplayerPlayer *pPlayer = ToBaseMultiplayerPlayer( pTeam->GetPlayer(i) );
if ( pPlayer && IsTouching( pPlayer ) )
{
pPlayer->StopScoringEscortPoints();
}
}
}
}
}
void magnet::update()
{
if(!is_activated())
{
return;
}
auto mag_pos = body_->GetWorldPoint(local_point_);
auto ce = body_->GetContactList();
// std::set< b2Body* > processed;
while(ce)
{
auto contact = ce->contact;
if(contact->IsTouching())
{
auto fixA = contact->GetFixtureA();
auto fixB = contact->GetFixtureB();
// b2Body* obj = nullptr;
b2Fixture* fix = nullptr;
if(fixA == sensor_)
{
// obj = fixB->GetBody();
fix = fixB;
}
else if(fixB == sensor_)
{
// obj = fixA->GetBody();
fix = fixA;
}
// if(obj != nullptr && processed.find(obj) == processed.end())
if(fix)
{
b2MassData md;
fix->GetMassData(&md);
auto metallic_mass = md.mass; // TODO: composition
auto obj_pos = fix->GetBody()->GetWorldPoint(md.center);
auto vec = mag_pos - obj_pos;
auto sqr_dist = vec.LengthSquared();
auto magnitude = strength_ * metallic_mass / sqr_dist;
vec *= magnitude / std::sqrt(sqr_dist);
fix->GetBody()->ApplyForce(vec, obj_pos, true);
body_->ApplyForce(-vec, mag_pos, true);
// processed.insert(obj);
}
}
ce = ce->next;
}
}
void CTriggerMultihop::Think()
{
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
if (pPlayer != NULL && m_fStartTouchedTime > 0)
{
if (IsTouching(pPlayer) && (gpGlobals->realtime - m_fStartTouchedTime >= m_fMaxHoldSeconds))
{
SetDestinationEnt(g_Timer.GetCurrentCheckpoint());
BaseClass::StartTouch(pPlayer);
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Called when an entity stops touching us.
// Input : pOther - The entity that was touching us.
//-----------------------------------------------------------------------------
void CTriggerWeaponStrip::EndTouch(CBaseEntity *pOther)
{
if ( IsTouching( pOther ) )
{
CBaseCombatCharacter *pCharacter = pOther->MyCombatCharacterPointer();
if ( pCharacter )
{
pCharacter->SetPreventWeaponPickup( false );
}
}
BaseClass::EndTouch( pOther );
}
void XnVPointDrawer::Draw() const
{
std::map<XnUInt32, std::list<XnPoint3D> >::const_iterator PointIterator;
// Go over each existing hand
for (PointIterator = m_History.begin();
PointIterator != m_History.end();
++PointIterator)
{
// Clear buffer
XnUInt32 nPoints = 0;
XnUInt32 i = 0;
XnUInt32 Id = PointIterator->first;
// Go over all previous positions of current hand
std::list<XnPoint3D>::const_iterator PositionIterator;
for (PositionIterator = PointIterator->second.begin();
PositionIterator != PointIterator->second.end();
++PositionIterator, ++i)
{
// Add position to buffer
XnPoint3D pt(*PositionIterator);
m_pfPositionBuffer[3*i] = pt.X;
m_pfPositionBuffer[3*i + 1] = pt.Y;
m_pfPositionBuffer[3*i + 2] = 0;//pt.Z();
}
// Set color
XnUInt32 nColor = Id % nColors;
XnUInt32 nSingle = GetPrimaryID();
if (Id == GetPrimaryID())
nColor = 6;
// Draw buffer:
glColor4f(Colors[nColor][0],
Colors[nColor][1],
Colors[nColor][2],
1.0f);
glPointSize(2);
glVertexPointer(3, GL_FLOAT, 0, m_pfPositionBuffer);
glDrawArrays(GL_LINE_STRIP, 0, i);
if (IsTouching(Id))
{
glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
}
glPointSize(8);
glDrawArrays(GL_POINTS, 0, 1);
glFlush();
}
}
//-----------------------------------------------------------------------------
// Purpose: Called when an entity stops touching us.
// Input : pOther - The entity that was touching us.
//-----------------------------------------------------------------------------
void CTriggerWateryDeath::EndTouch( CBaseEntity *pOther )
{
if ( IsTouching( pOther ) )
{
EHANDLE hOther;
hOther = pOther;
// Remove the time from our list
int iIndex = m_hTouchingEntities.Find( hOther );
if ( iIndex != m_hTouchingEntities.InvalidIndex() )
{
m_flEntityKillTimes.Remove( iIndex );
}
}
#ifdef HL2_DLL
if ( pOther->IsPlayer() )
{
for (int i = 0; i < m_hLeeches.Count(); i++ )
{
CWateryDeathLeech *pLeech = dynamic_cast<CWateryDeathLeech*>( m_hLeeches[i].Get() );
if ( pLeech )
{
pLeech->m_iFadeState = -1;
}
}
if ( m_hLeeches.Count() > 0 )
m_hLeeches.Purge();
CHL2_Player *pHL2Player = dynamic_cast<CHL2_Player*>( pOther );
if ( pHL2Player )
{
//Adrian: Hi, you might be wondering why I'm doing this, yes?
// Well, EndTouch is called not only when the player leaves
// the trigger, but also on level shutdown. We can't let the
// soundpatch fade the sound out since we'll hit a nasty assert
// cause it'll try to fade out a sound using an entity that might
// be gone since we're shutting down the server.
if ( !(pHL2Player->GetFlags() & FL_DONTTOUCH ) )
pHL2Player->StopWaterDeathSounds();
}
}
#endif
BaseClass::EndTouch( pOther );
}
//-----------------------------------------------------------------------------
// Purpose: Check if this player's death causes a block
// return FALSE if the player is not in this area
// return TRUE otherwise ( eg player is in area, but his death does not cause break )
//-----------------------------------------------------------------------------
bool CTriggerAreaCapture::CheckIfDeathCausesBlock( CBaseMultiplayerPlayer *pVictim, CBaseMultiplayerPlayer *pKiller )
{
if ( !pVictim || !pKiller )
return false;
// make sure this player is in this area
if ( !IsTouching( pVictim ) )
return false;
// Teamkills shouldn't give a block reward
if ( pVictim->GetTeamNumber() == pKiller->GetTeamNumber() )
return true;
// return if the area is not being capped
if ( !m_bCapturing )
return true;
int iTeam = pVictim->GetTeamNumber();
// return if this player's team is not capping the area
if ( iTeam != m_nCapturingTeam )
return true;
// break early incase we kill multiple people in the same frame
bool bBreakCap = false;
if ( CaptureModeScalesWithPlayers() )
{
bBreakCap = ( m_TeamData[m_nCapturingTeam].iBlockedTouching - 1 ) <= 0;
}
else
{
bBreakCap = ( m_TeamData[m_nCapturingTeam].iBlockedTouching - 1 < m_TeamData[m_nCapturingTeam].iNumRequiredToCap );
}
if ( bBreakCap )
{
m_hPoint->CaptureBlocked( pKiller );
//BreakCapture( true );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTriggerAreaCapture::EndTouch(CBaseEntity *pOther)
{
if ( IsTouching( pOther ) && m_hPoint )
{
IGameEvent *event = gameeventmanager->CreateEvent( "controlpoint_endtouch" );
if ( event )
{
event->SetInt( "player", pOther->entindex() );
event->SetInt( "area", m_hPoint->GetPointIndex() );
gameeventmanager->FireEvent( event );
}
// incase we leave but the area keeps capturing
CBaseMultiplayerPlayer *pPlayer = ToBaseMultiplayerPlayer(pOther);
if ( pPlayer )
{
pPlayer->StopScoringEscortPoints();
}
}
BaseClass::EndTouch( pOther );
}
bool CP_Sphere::IsTouching(Vec3D<>* P, Vec3D<>* Dist, Vec3D<>* Envelope)
{
return IsTouching(P, Dist->Length(), Envelope); //not quite right, but decent approximation for now...
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTriggerAreaCapture::BreakCapture( bool bNotEnoughPlayers )
{
if( m_bCapturing )
{
// Remap team to get first game team = 1
switch ( m_nCapturingTeam - FIRST_GAME_TEAM+1 )
{
case 1:
m_OnBreakTeam1.FireOutput( this, this );
break;
case 2:
m_OnBreakTeam2.FireOutput( this, this );
break;
default:
Assert(0);
break;
}
m_BreakOutput.FireOutput(this,this);
m_bCapturing = false;
m_nCapturingTeam = TEAM_UNASSIGNED;
UpdateCappingTeam( TEAM_UNASSIGNED );
if ( bNotEnoughPlayers )
{
IncrementCapAttemptNumber();
}
SetCapTimeRemaining( 0 );
if( m_hPoint )
{
m_hPoint->CaptureEnd();
// The point reverted to it's previous owner.
IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_capture_broken" );
if ( event )
{
event->SetInt( "cp", m_hPoint->GetPointIndex() );
event->SetString( "cpname", m_hPoint->GetName() );
event->SetFloat( "time_remaining", m_fTimeRemaining );
gameeventmanager->FireEvent( event );
}
}
SetNumCappers( 0 );
// tell all touching players to stop racking up capture points
CTeam *pTeam = GetGlobalTeam( m_nCapturingTeam );
if ( pTeam )
{
for ( int i=0;i<pTeam->GetNumPlayers();i++ )
{
CBaseMultiplayerPlayer *pPlayer = ToBaseMultiplayerPlayer( pTeam->GetPlayer(i) );
if ( pPlayer && IsTouching( pPlayer ) )
{
pPlayer->StopScoringEscortPoints();
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTriggerAreaCapture::EndCapture( int team )
{
IncrementCapAttemptNumber();
// Remap team to get first game team = 1
switch ( team - FIRST_GAME_TEAM+1 )
{
case 1:
m_OnCapTeam1.FireOutput( this, this );
break;
case 2:
m_OnCapTeam2.FireOutput( this, this );
break;
default:
Assert(0);
break;
}
m_CapOutput.FireOutput(this,this);
int numcappers = 0;
int cappingplayers[MAX_AREA_CAPPERS];
GetNumCappingPlayers( team, numcappers, cappingplayers );
// Handle this before we assign the new team as the owner of this area
HandleRespawnTimeAdjustments( m_nOwningTeam, team );
m_nOwningTeam = team;
m_bCapturing = false;
m_nCapturingTeam = TEAM_UNASSIGNED;
SetCapTimeRemaining( 0 );
//there may have been more than one capper, but only report this one.
//he hasn't gotten points yet, and his name will go in the cap string if its needed
//first capper gets name sent and points given by flag.
//other cappers get points manually above, no name in message
//send the player in the cap string
if( m_hPoint )
{
OnEndCapture( m_nOwningTeam );
UpdateOwningTeam();
m_hPoint->SetOwner( m_nOwningTeam, true, numcappers, cappingplayers );
m_hPoint->CaptureEnd();
}
SetNumCappers( 0 );
// tell all touching players to stop racking up capture points
CTeam *pTeam = GetGlobalTeam( m_nCapturingTeam );
if ( pTeam )
{
for ( int i=0;i<pTeam->GetNumPlayers();i++ )
{
CBaseMultiplayerPlayer *pPlayer = ToBaseMultiplayerPlayer( pTeam->GetPlayer(i) );
if ( pPlayer && IsTouching( pPlayer ) )
{
pPlayer->StopScoringEscortPoints();
}
}
}
// play any special cap sounds
if ( TeamplayRoundBasedRules() )
{
TeamplayRoundBasedRules()->PlaySpecialCapSounds( m_nOwningTeam );
}
}
void CButton::CheckState()
{
m_state = IsTouching() ? ButtonStateHighlight : ButtonStateNormal;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTriggerAreaCapture::StartCapture( int team, int capmode )
{
// Remap team to get first game team = 1
switch ( team - FIRST_GAME_TEAM+1 )
{
case 1:
m_OnStartTeam1.FireOutput( this, this );
break;
case 2:
m_OnStartTeam2.FireOutput( this, this );
break;
default:
Assert(0);
break;
}
m_StartOutput.FireOutput(this,this);
m_nCapturingTeam = team;
UpdateNumPlayers();
if ( CaptureModeScalesWithPlayers() )
{
SetCapTimeRemaining( ((m_flCapTime * 2) * m_TeamData[team].iNumRequiredToCap) );
}
else
{
SetCapTimeRemaining( m_flCapTime );
}
m_bCapturing = true;
m_bBlocked = false;
m_iCapMode = capmode;
m_flLastReductionTime = gpGlobals->curtime;
UpdateCappingTeam( m_nCapturingTeam );
UpdateBlocked();
if( m_hPoint )
{
int numcappers = 0;
int cappingplayers[MAX_AREA_CAPPERS];
GetNumCappingPlayers( m_nCapturingTeam, numcappers, cappingplayers );
m_hPoint->CaptureStart( m_nCapturingTeam, numcappers, cappingplayers );
}
// tell all touching players to start racking up capture points
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( pMaster )
{
float flRate = pMaster->GetPartialCapturePointRate();
if ( flRate > 0.0f )
{
// for each player touch
CTeam *pTeam = GetGlobalTeam( m_nCapturingTeam );
if ( pTeam )
{
for ( int i=0;i<pTeam->GetNumPlayers();i++ )
{
CBaseMultiplayerPlayer *pPlayer = ToBaseMultiplayerPlayer( pTeam->GetPlayer(i) );
if ( pPlayer && IsTouching( pPlayer ) )
{
pPlayer->StartScoringEscortPoints( flRate );
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTriggerAreaCapture::CaptureThink( void )
{
SetNextThink( gpGlobals->curtime + AREA_THINK_TIME );
// make sure this point is in the round being played (if we're playing one)
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( pMaster && m_hPoint )
{
if ( !pMaster->IsInRound( m_hPoint ) )
{
return;
}
}
if ( !TeamplayGameRules()->PointsMayBeCaptured() )
{
// Points aren't allowed to be captured. If we were
// being captured, we need to clean up and reset.
if ( m_bCapturing )
{
BreakCapture( false );
UpdateNumPlayers();
}
return;
}
// go through our list of players
Assert( GetNumberOfTeams() <= MAX_CAPTURE_TEAMS );
int iNumPlayers[MAX_CAPTURE_TEAMS];
int iNumBlockablePlayers[MAX_CAPTURE_TEAMS]; // Players in the zone who can't cap, but can block / pause caps
CBaseMultiplayerPlayer *pFirstPlayerTouching[MAX_CAPTURE_TEAMS];
for ( int i = FIRST_GAME_TEAM; i < GetNumberOfTeams(); i++ )
{
iNumPlayers[i] = 0;
iNumBlockablePlayers[i] = 0;
pFirstPlayerTouching[i] = NULL;
}
if ( m_hPoint )
{
// Loop through the entities we're touching, and find players
for ( int i = 0; i < m_hTouchingEntities.Count(); i++ )
{
CBaseEntity *ent = m_hTouchingEntities[i];
if ( ent && ent->IsPlayer() )
{
CBaseMultiplayerPlayer *pPlayer = ToBaseMultiplayerPlayer(ent);
if ( pPlayer->IsAlive() )
{
int iTeam = pPlayer->GetTeamNumber();
// If a team's not allowed to cap a point, don't count players in it at all
if ( !TeamplayGameRules()->TeamMayCapturePoint( iTeam, m_hPoint->GetPointIndex() ) )
continue;
if ( !TeamplayGameRules()->PlayerMayCapturePoint( pPlayer, m_hPoint->GetPointIndex() ) )
{
if ( TeamplayGameRules()->PlayerMayBlockPoint( pPlayer, m_hPoint->GetPointIndex() ) )
{
if ( iNumPlayers[iTeam] == 0 && iNumBlockablePlayers[iTeam] == 0 )
{
pFirstPlayerTouching[iTeam] = pPlayer;
}
iNumBlockablePlayers[iTeam] += TeamplayGameRules()->GetCaptureValueForPlayer( pPlayer );
}
continue;
}
if ( iTeam >= FIRST_GAME_TEAM )
{
if ( iNumPlayers[iTeam] == 0 && iNumBlockablePlayers[iTeam] == 0 )
{
pFirstPlayerTouching[iTeam] = pPlayer;
}
iNumPlayers[iTeam] += TeamplayGameRules()->GetCaptureValueForPlayer( pPlayer );
}
}
}
}
}
int iTeamsInZone = 0;
bool bUpdatePlayers = false;
m_nTeamInZone = TEAM_UNASSIGNED;
for ( int i = FIRST_GAME_TEAM; i < GetNumberOfTeams(); i++ )
{
iNumPlayers[i] *= mp_simulatemultiplecappers.GetInt();
if ( m_TeamData[i].iNumTouching != iNumPlayers[i] )
{
m_TeamData[i].iNumTouching = iNumPlayers[i];
bUpdatePlayers = true;
}
m_TeamData[i].iBlockedTouching = m_TeamData[i].iNumTouching;
if ( m_TeamData[i].iNumTouching )
{
iTeamsInZone++;
m_nTeamInZone = i;
}
}
if ( iTeamsInZone > 1 )
{
m_nTeamInZone = TEAM_UNASSIGNED;
}
else
{
// If we've got non-cappable, yet blockable players here for the team that's defending, they
// need to block the cap. This catches cases like the TF invulnerability, which needs to block
// caps, but isn't allowed to contribute to a cap.
for ( int i = FIRST_GAME_TEAM; i < GetNumberOfTeams(); i++ )
{
if ( !iNumBlockablePlayers[i] || m_nTeamInZone == i )
continue;
iTeamsInZone++;
}
}
UpdateTeamInZone();
bool bBlocked = false;
// If the cap is being blocked, reset the number of players so the client
// knows to stop the capture as well.
if ( mp_blockstyle.GetInt() == 1 )
{
if ( m_bCapturing && iTeamsInZone > 1 )
{
bBlocked = true;
for ( int i = FIRST_GAME_TEAM; i < GetNumberOfTeams(); i++ )
{
iNumPlayers[i] = 0;
if ( m_TeamData[i].iNumTouching != iNumPlayers[i] )
{
m_TeamData[i].iNumTouching = iNumPlayers[i];
bUpdatePlayers = true;
}
}
}
}
if ( bUpdatePlayers )
{
UpdateNumPlayers( bBlocked );
}
// When a player blocks, tell them the cap index and attempt number
// only give successive blocks to them if the attempt number is different
if ( m_bCapturing )
{
if ( m_hPoint )
{
m_hPoint->SetLastContestedAt( gpGlobals->curtime );
}
// Calculate the amount of modification to the cap time
float flTimeDelta = gpGlobals->curtime - m_flLastReductionTime;
float flReduction = flTimeDelta;
if ( CaptureModeScalesWithPlayers() )
{
// Diminishing returns for successive players.
for ( int i = 1; i < m_TeamData[m_nTeamInZone].iNumTouching; i++ )
{
flReduction += (flTimeDelta / (float)(i+1));
}
}
m_flLastReductionTime = gpGlobals->curtime;
//if more than one team is in the zone
if( iTeamsInZone > 1 )
{
if ( !m_bBlocked )
{
m_bBlocked = true;
UpdateBlocked();
}
// See if anyone gets credit for the block
float flPercentToGo = m_fTimeRemaining / m_flCapTime;
if ( CaptureModeScalesWithPlayers() )
{
flPercentToGo = m_fTimeRemaining / ((m_flCapTime * 2) * m_TeamData[m_nCapturingTeam].iNumRequiredToCap);
}
if ( ( flPercentToGo <= 0.5 || TeamplayGameRules()->PointsMayAlwaysBeBlocked() ) && m_hPoint )
{
// find the first player that is not on the capturing team
// they have just broken a cap and should be rewarded
// tell the player the capture attempt number, for checking later
CBaseMultiplayerPlayer *pBlockingPlayer = NULL;
for ( int i = FIRST_GAME_TEAM; i < GetNumberOfTeams(); i++ )
{
if ( m_nCapturingTeam == i )
continue;
if ( pFirstPlayerTouching[i] )
{
pBlockingPlayer = pFirstPlayerTouching[i];
break;
}
}
Assert( pBlockingPlayer );
if ( pBlockingPlayer )
{
bool bRepeatBlocker = false;
for ( int i = m_Blockers.Count()-1; i >= 0; i-- )
{
if ( m_Blockers[i].hPlayer != pBlockingPlayer )
continue;
// If this guy's was a blocker, but not valid now, remove him from the list
if ( m_Blockers[i].iCapAttemptNumber != m_iCapAttemptNumber || !IsTouching(m_Blockers[i].hPlayer) ||
( TeamplayGameRules()->PointsMayAlwaysBeBlocked() && m_Blockers[i].flNextBlockTime < gpGlobals->curtime && m_bStartTouch ) )
{
m_Blockers.Remove(i);
continue;
}
bRepeatBlocker = true;
break;
}
if ( !bRepeatBlocker )
{
m_hPoint->CaptureBlocked( pBlockingPlayer );
// Add this guy to our blocker list
int iNew = m_Blockers.AddToTail();
m_Blockers[iNew].hPlayer = pBlockingPlayer;
m_Blockers[iNew].iCapAttemptNumber = m_iCapAttemptNumber;
m_Blockers[iNew].flNextBlockTime = gpGlobals->curtime + 10.0f;
}
}
}
if ( mp_blockstyle.GetInt() == 0 )
{
BreakCapture( false );
}
return;
}
if ( m_bBlocked )
{
m_bBlocked = false;
UpdateBlocked();
}
float flTotalTimeToCap = m_flCapTime;
if ( CaptureModeScalesWithPlayers() )
{
flTotalTimeToCap = ((m_flCapTime * 2) * m_TeamData[m_nCapturingTeam].iNumRequiredToCap);
}
// Now remove the reduction amount after we've determined there's only 1 team in the area
if ( m_nCapturingTeam == m_nTeamInZone )
{
SetCapTimeRemaining( m_fTimeRemaining - flReduction );
}
else if ( m_nOwningTeam == TEAM_UNASSIGNED && m_nTeamInZone != TEAM_UNASSIGNED )
{
SetCapTimeRemaining( m_fTimeRemaining + flReduction );
}
else
{
// Caps deteriorate over time
if ( TeamplayRoundBasedRules() && m_hPoint && TeamplayRoundBasedRules()->TeamMayCapturePoint(m_nCapturingTeam,m_hPoint->GetPointIndex()) )
{
float flDecreaseScale = CaptureModeScalesWithPlayers() ? mp_capdeteriorate_time.GetFloat() : flTotalTimeToCap;
float flDecrease = (flTotalTimeToCap / flDecreaseScale) * flTimeDelta;
if ( TeamplayRoundBasedRules() && TeamplayRoundBasedRules()->InOvertime() )
{
flDecrease *= 6;
}
SetCapTimeRemaining( m_fTimeRemaining + flDecrease );
}
else
{
SetCapTimeRemaining( flTotalTimeToCap );
}
}
/*
//if no-one is in the area
if( iTeamsInZone == 0 )
{
BreakCapture( true );
return;
}
//if they've lost the number of players needed to cap
int iTeamMembersHere = m_TeamData[m_nCapturingTeam].iNumTouching + iNumBlockablePlayers[m_nCapturingTeam];
if ( (iTeamMembersHere == 0 ) || (mp_capstyle.GetInt() == 0 && iTeamMembersHere < m_TeamData[m_nCapturingTeam].iNumRequiredToCap) )
{
BreakCapture( true );
return;
}
*/
// if the cap is done
if ( m_fTimeRemaining <= 0 )
{
EndCapture( m_nCapturingTeam );
return; //we're done
}
else
{
// We may get several simultaneous CaptureThink calls from StartTouch if there are several players on the trigger
// when it is enabled (like in Raid mode). We haven't started reducing m_fTimeRemaining yet but the second call to CaptureThink
// from StartTouch has m_bCapturing set to true and we hit this condition and call BreakCapture right away.
// We put this check here to prevent calling BreakCapture from the StartTouch call to CaptureThink. If the capture should
// really be broken it will happen the next time the trigger thinks on its own.
if ( !m_bStartTouch )
{
if ( m_fTimeRemaining >= flTotalTimeToCap )
{
BreakCapture( false );
return;
}
}
}
}
else
{
// If there are any teams in the zone that aren't the owner, try to start capping
if ( iTeamsInZone > 0 )
{
for ( int i = FIRST_GAME_TEAM; i < GetNumberOfTeams(); i++ )
{
if ( !m_TeamData[i].bCanCap || m_nOwningTeam == i )
continue;
if ( m_TeamData[i].iNumTouching == 0 )
continue;
if ( m_TeamData[i].iNumTouching < m_TeamData[i].iNumRequiredToStartCap )
continue;
if ( !CaptureModeScalesWithPlayers() && m_TeamData[i].iNumTouching < m_TeamData[i].iNumRequiredToCap )
continue;
StartCapture( i, CAPTURE_NORMAL );
break;
}
}
}
}