CTG & JGR Overtime (#1342)

* ghost overtime

* keep original timer, fade out inactive timer

* jgr overtime

* major streamline

- Overtime starts at 0 seconds
- Grace period always starts at the same amount of time
- HUD simplified to a single timer, turns red if in grace time
- Overtime timer stays the same (will continue counting) but will override the grace timer if it goes lower than the base grace time

* red outside of ctg

* undo overtime start point change

* fix

- prevent grace timer being overriden by overtime timer when ghost is not held
- fix the overtime starting when it shouldnt

* grace decay returns

* cleanup

* ditch unnecessary network var

---------

Co-authored-by: AdamTadeusz <adam.tomaszewski@hotmail.co.uk>

Author: DESTROYGIRL

src/game/client/neo/ui/neo_hud_round_state.cpp

@@ -41,6 +41,7 @@ extern ConVar cl_neo_streamermode;
 extern ConVar snd_victory_volume;
 extern ConVar sv_neo_readyup_countdown;
 extern ConVar cl_neo_hud_scoreboard_hide_others;
+extern ConVar sv_neo_ctg_ghost_overtime_grace;
 
 namespace {
 constexpr int Y_POS = 0;
@@ -319,6 +320,10 @@ void CNEOHud_RoundState::UpdateStateForNeoHudElementDraw()
 	{
 		m_iWszRoundUCSize = V_swprintf_safe(m_wszRoundUnicode, L"STARTING");
 	}
+	else if (NEORules()->GetRoundStatus() == NeoRoundStatus::Overtime)
+	{
+		m_iWszRoundUCSize = V_swprintf_safe(m_wszRoundUnicode, L"OVERTIME");
+	}
 	else
 	{
 		if (NEORules()->GetGameType() == NEO_GAME_TYPE_DM)
@@ -334,7 +339,16 @@ void CNEOHud_RoundState::UpdateStateForNeoHudElementDraw()
 	if (roundStatus == NeoRoundStatus::PreRoundFreeze)
 		roundTimeLeft = NEORules()->GetRemainingPreRoundFreezeTime(true);
 
-	const int secsTotal = RoundFloatToInt(roundTimeLeft);
+	int secsTotal = 0.0f;
+	if (roundStatus == NeoRoundStatus::Overtime && NEORules()->GetGameType() == NEO_GAME_TYPE_CTG)
+	{
+		secsTotal = RoundFloatToInt(NEORules()->GetCTGOverTime());
+	}
+	else
+	{
+		secsTotal = RoundFloatToInt(roundTimeLeft);
+	}
+
 	const int secsRemainder = secsTotal % 60;
 	const int minutes = (secsTotal - secsRemainder) / 60;
 	V_snwprintf(m_wszTime, 6, L"%02d:%02d", minutes, secsRemainder);
@@ -465,9 +479,15 @@ void CNEOHud_RoundState::DrawNeoHudElement()
 	// Draw time
 	surface()->DrawSetTextFont(m_hOCRFont);
 	surface()->GetTextSize(m_hOCRFont, m_wszTime, fontWidth, fontHeight);
-	surface()->DrawSetTextColor((NEORules()->GetRoundStatus() == NeoRoundStatus::PreRoundFreeze ||
-								 NEORules()->GetRoundStatus() == NeoRoundStatus::Countdown) ?
-									COLOR_RED : COLOR_WHITE);
+	if (NEORules()->GetRoundStatus() == NeoRoundStatus::PreRoundFreeze || NEORules()->GetRoundStatus() == NeoRoundStatus::Countdown || NEORules()->GetGameType() == NEO_GAME_TYPE_CTG ?
+		(NEORules()->GetRoundStatus() == NeoRoundStatus::Overtime && (NEORules()->GetRoundRemainingTime() < sv_neo_ctg_ghost_overtime_grace.GetFloat())) : NEORules()->GetRoundStatus() == NeoRoundStatus::Overtime)
+	{
+		surface()->DrawSetTextColor(COLOR_RED);
+	}
+	else
+	{
+		surface()->DrawSetTextColor(COLOR_WHITE);
+	}
 	surface()->DrawSetTextPos(m_iXpos - (fontWidth / 2), m_iBoxYEnd / 2 - fontHeight / 2);
 	surface()->DrawPrintText(m_wszTime, 6);
 

src/game/server/neo/neo_player.cpp

@@ -189,7 +189,7 @@ void CNEO_Player::RequestSetClass(int newClass)
 void CNEO_Player::RequestSetSkin(int newSkin)
 {
 	const NeoRoundStatus roundStatus = NEORules()->GetRoundStatus();
-	bool canChangeImmediately = ((roundStatus != NeoRoundStatus::RoundLive) && (roundStatus != NeoRoundStatus::PostRound)) || !IsAlive();
+	bool canChangeImmediately = ((roundStatus != NeoRoundStatus::RoundLive) && (roundStatus != NeoRoundStatus::Overtime) && (roundStatus != NeoRoundStatus::PostRound)) || !IsAlive();
 
 	if (canChangeImmediately)
 	{
@@ -2854,7 +2854,7 @@ int	CNEO_Player::OnTakeDamage_Alive(const CTakeDamageInfo& info)
 				m_rfAttackersAccumlator.Set(attackerIdx, flDmgAccumlator);
 				m_rfAttackersHits.GetForModify(attackerIdx) += 1;
 
-				if (bIsTeamDmg && sv_neo_teamdamage_kick.GetBool() && NEORules()->GetRoundStatus() == NeoRoundStatus::RoundLive)
+				if (bIsTeamDmg && sv_neo_teamdamage_kick.GetBool() && NEORules()->IsRoundLive())
 				{
 					attacker->m_iTeamDamageInflicted += iDamage;
 				}

src/game/shared/neo/neo_gamerules.cpp

@@ -65,7 +65,8 @@ ConVar neo_vip_eligible("cl_neo_vip_eligible", "1", FCVAR_ARCHIVE, "Eligible for
 #endif // CLIENT_DLL
 #ifdef GAME_DLL
 ConVar sv_neo_vip_ctg_on_death("sv_neo_vip_ctg_on_death", "0", FCVAR_ARCHIVE, "Spawn Ghost when VIP dies, continue the game", true, 0, true, 1);
-ConVar sv_neo_jgr_max_points("sv_neo_jgr_max_points", "100", FCVAR_ARCHIVE, "Maximum points required for a team to win in JGR", true, 1, false, 0);
+ConVar sv_neo_jgr_max_points("sv_neo_jgr_max_points", "100", FCVAR_REPLICATED, "Maximum points required for a team to win in JGR", true, 1, false, 0);
+ConVar sv_neo_jgr_point_interval("sv_neo_jgr_point_interval", "1.5", FCVAR_REPLICATED, "Amount of time required to score a point whilst holding the Juggernaut", true, 0.1f, false, 0);
 #endif
 
 #ifdef GAME_DLL
@@ -230,6 +231,7 @@ BEGIN_NETWORK_TABLE_NOBASE( CNEORules, DT_NEORules )
 	RecvPropInt(RECVINFO(m_iGhosterPlayer)),
 	RecvPropInt(RECVINFO(m_iEscortingTeam)),
 	RecvPropBool(RECVINFO(m_bGhostExists)),
+	RecvPropFloat(RECVINFO(m_flGhostLastHeld)),
 	RecvPropVector(RECVINFO(m_vecGhostMarkerPos)),
 	RecvPropInt(RECVINFO(m_iJuggernautPlayerIndex)),
 	RecvPropBool(RECVINFO(m_bJuggernautItemExists)),
@@ -252,6 +254,7 @@ BEGIN_NETWORK_TABLE_NOBASE( CNEORules, DT_NEORules )
 	SendPropInt(SENDINFO(m_iGhosterPlayer)),
 	SendPropInt(SENDINFO(m_iEscortingTeam)),
 	SendPropBool(SENDINFO(m_bGhostExists)),
+	SendPropFloat(SENDINFO(m_flGhostLastHeld)),
 	SendPropVector(SENDINFO(m_vecGhostMarkerPos), -1, SPROP_COORD_MP_LOWPRECISION | SPROP_CHANGES_OFTEN, MIN_COORD_FLOAT, MAX_COORD_FLOAT),
 	SendPropInt(SENDINFO(m_iJuggernautPlayerIndex)),
 	SendPropBool(SENDINFO(m_bJuggernautItemExists)),
@@ -375,6 +378,10 @@ ConVar sv_neo_ignore_wep_xp_limit("sv_neo_ignore_wep_xp_limit", "0", FCVAR_CHEAT
 ConVar sv_neo_dm_win_xp("sv_neo_dm_win_xp", "50", FCVAR_REPLICATED, "The XP limit to win the match.",
 	true, 0.0f, true, 1000.0f);
 
+ConVar sv_neo_ctg_ghost_overtime_enabled("sv_neo_ctg_ghost_overtime_enabled", "0", FCVAR_REPLICATED, "Enable ghost overtime.", true, 0, true, 1);
+ConVar sv_neo_ctg_ghost_overtime("sv_neo_ctg_ghost_overtime", "45", FCVAR_REPLICATED, "Adds up to this many seconds to the round while the ghost is held.", true, 0, true, 120);
+ConVar sv_neo_ctg_ghost_overtime_grace("sv_neo_ctg_ghost_overtime_grace", "10", FCVAR_REPLICATED, "Number of seconds left in the round when the ghost is dropped in overtime.", true, 0, true, 30);
+ConVar sv_neo_ctg_ghost_overtime_grace_decay("sv_neo_ctg_ghost_overtime_grace_decay", "0", FCVAR_REPLICATED, "Slowly reduce the grace time as overtime goes on.", true, 0, true, 1);
 
 #ifdef CLIENT_DLL
 extern ConVar neo_fov;
@@ -676,6 +683,7 @@ void CNEORules::ResetMapSessionCommon()
 	m_vecJuggernautMarkerPos = vec3_origin;
 	m_flNeoRoundStartTime = 0.0f;
 	m_flNeoNextRoundStartTime = 0.0f;
+	m_flGhostLastHeld = 0.0f;
 #ifdef GAME_DLL
 	m_pRestoredInfos.Purge();
 	m_readyAccIDs.Purge();
@@ -1055,6 +1063,20 @@ void CNEORules::Think(void)
 		return;
 	}
 
+	if (m_nGameTypeSelected == NEO_GAME_TYPE_CTG)
+	{
+		if (sv_neo_ctg_ghost_overtime_enabled.GetBool() && m_nRoundStatus == NeoRoundStatus::RoundLive && m_iGhosterPlayer &&
+			(m_flNeoRoundStartTime + (neo_ctg_round_timelimit.GetFloat() * 60) - sv_neo_ctg_ghost_overtime_grace.GetFloat()) < gpGlobals->curtime)
+		{
+			m_nRoundStatus = NeoRoundStatus::Overtime;
+		}
+
+		if (m_nRoundStatus == NeoRoundStatus::Overtime && m_iGhosterPlayer)
+		{
+			m_flGhostLastHeld = gpGlobals->curtime;
+		}
+	}
+
 	if (g_fGameOver)   // someone else quit the game already
 	{
 		// check to see if we should change levels now
@@ -1089,7 +1111,7 @@ void CNEORules::Think(void)
 		m_flPrevThinkMirrorDmg = gpGlobals->curtime;
 	}
 
-	if (sv_neo_teamdamage_kick.GetBool() && m_nRoundStatus == NeoRoundStatus::RoundLive &&
+	if (sv_neo_teamdamage_kick.GetBool() && IsRoundLive() &&
 			gpGlobals->curtime > (m_flPrevThinkKick + 0.5f))
 	{
 		const int iThresKickHp = sv_neo_teamdamage_kick_hp.GetInt();
@@ -1145,7 +1167,7 @@ void CNEORules::Think(void)
 	// Note that exactly zero here means infinite round time.
 	else if (GetRoundRemainingTime() < 0)
 	{
-		if (GetGameType() == NEO_GAME_TYPE_TDM || GetGameType() == NEO_GAME_TYPE_JGR)
+		if (GetGameType() == NEO_GAME_TYPE_TDM)
 		{
 			if (GetGlobalTeam(TEAM_JINRAI)->GetScore() > GetGlobalTeam(TEAM_NSF)->GetScore())
 			{
@@ -1173,6 +1195,47 @@ void CNEORules::Think(void)
 			}
 			// Otherwise go into overtime
 		}
+		else if (GetGameType() == NEO_GAME_TYPE_JGR)
+		{
+			if (!m_pJuggernautPlayer)
+			{
+				if (GetGlobalTeam(TEAM_JINRAI)->GetScore() > GetGlobalTeam(TEAM_NSF)->GetScore())
+				{
+					SetWinningTeam(TEAM_JINRAI, NEO_VICTORY_POINTS, false, true, false, false);
+					return;
+				}
+
+				if (GetGlobalTeam(TEAM_NSF)->GetScore() > GetGlobalTeam(TEAM_JINRAI)->GetScore())
+				{
+					SetWinningTeam(TEAM_NSF, NEO_VICTORY_POINTS, false, true, false, false);
+					return;
+				}
+			}
+			else
+			{
+				if (m_nRoundStatus == NeoRoundStatus::RoundLive)
+				{
+					m_nRoundStatus = NeoRoundStatus::Overtime;
+				}
+
+				int jgrTeam = m_pJuggernautPlayer->GetTeamNumber();
+				int oppositeTeam = (m_pJuggernautPlayer->GetTeamNumber() == TEAM_JINRAI ? TEAM_NSF : TEAM_JINRAI);
+				if (GetGlobalTeam(jgrTeam)->GetScore() > GetGlobalTeam(oppositeTeam)->GetScore())
+				{
+					SetWinningTeam(jgrTeam, NEO_VICTORY_POINTS, false, true, false, false);
+					return;
+				}
+
+				if (gpGlobals->curtime >= m_flLastPointTime)
+				{
+					m_flLastPointTime = gpGlobals->curtime + sv_neo_jgr_point_interval.GetFloat();
+
+					GetGlobalTeam(jgrTeam)->AddScore(1);
+				}
+
+				return;
+			}
+		}
 
 		if (IsTeamplay())
 		{
@@ -1306,13 +1369,11 @@ void CNEORules::Think(void)
 		m_bJuggernautItemExists = false;
 	}
 
-#define JGR_POINT_INTERVAL 1.5f
-
-	if (GetGameType() == NEO_GAME_TYPE_JGR && m_nRoundStatus == NeoRoundStatus::RoundLive && m_pJuggernautPlayer)
+	if (GetGameType() == NEO_GAME_TYPE_JGR && IsRoundLive() && m_pJuggernautPlayer)
 	{
 		if (gpGlobals->curtime >= m_flLastPointTime)
 		{
-			m_flLastPointTime = gpGlobals->curtime + JGR_POINT_INTERVAL;
+			m_flLastPointTime = gpGlobals->curtime + sv_neo_jgr_point_interval.GetFloat();
 
 			if (m_pJuggernautPlayer->GetTeamNumber() == TEAM_JINRAI)
 			{
@@ -1337,7 +1398,7 @@ void CNEORules::Think(void)
 		}
 	}
 
-	if (GetGameType() == NEO_GAME_TYPE_VIP && m_nRoundStatus == NeoRoundStatus::RoundLive && !m_pGhost)
+	if (GetGameType() == NEO_GAME_TYPE_VIP && IsRoundLive() && !m_pGhost)
 	{
 		if (!m_pVIP)
 		{
@@ -1429,7 +1490,7 @@ void CNEORules::Think(void)
 			}
 		}
 	}
-	else if (m_nRoundStatus != NeoRoundStatus::RoundLive)
+	else if (!IsRoundLive())
 	{
 		if (!IsRoundOver())
 		{
@@ -1441,7 +1502,7 @@ void CNEORules::Think(void)
 	}
 	else
 	{
-		if (m_nRoundStatus == NeoRoundStatus::RoundLive)
+		if (IsRoundLive())
 		{
 			COMPILE_TIME_ASSERT(TEAM_JINRAI == 2 && TEAM_NSF == 3);
 			if (GetGameType() != NEO_GAME_TYPE_TDM && GetGameType() != NEO_GAME_TYPE_DM && GetGameType() != NEO_GAME_TYPE_JGR)
@@ -1596,6 +1657,10 @@ float CNEORules::GetRoundRemainingTime() const
 				break;
 			case NEO_GAME_TYPE_CTG:
 				roundTimeLimit = neo_ctg_round_timelimit.GetFloat() * 60.f;
+				if (m_nRoundStatus == NeoRoundStatus::Overtime)
+				{
+					return GetCTGOverTime();
+				}
 				break;
 			case NEO_GAME_TYPE_VIP:
 				roundTimeLimit = neo_vip_round_timelimit.GetFloat() * 60.f;
@@ -1614,6 +1679,37 @@ float CNEORules::GetRoundRemainingTime() const
 	return (m_flNeoRoundStartTime + roundTimeLimit) - gpGlobals->curtime;
 }
 
+float CNEORules::GetCTGOverTime() const
+{
+	float roundTimeLimit = neo_ctg_round_timelimit.GetFloat() * 60.f;
+	float overtime = (m_flNeoRoundStartTime + roundTimeLimit + sv_neo_ctg_ghost_overtime.GetFloat()) - gpGlobals->curtime;
+
+	if (sv_neo_ctg_ghost_overtime_grace_decay.GetBool())
+	{
+		if (m_iGhosterPlayer)
+		{
+			return overtime;
+		}
+		else
+		{
+			float overtimeAtGhostDrop = (m_flNeoRoundStartTime + roundTimeLimit + sv_neo_ctg_ghost_overtime.GetFloat()) - m_flGhostLastHeld;
+			return (overtimeAtGhostDrop * sv_neo_ctg_ghost_overtime_grace.GetFloat() / (sv_neo_ctg_ghost_overtime.GetFloat() + sv_neo_ctg_ghost_overtime_grace.GetFloat())) - (gpGlobals->curtime - m_flGhostLastHeld);
+		}
+	}
+	else
+	{
+		float grace = sv_neo_ctg_ghost_overtime_grace.GetFloat() - (gpGlobals->curtime - m_flGhostLastHeld);
+		if (m_iGhosterPlayer || overtime < grace)
+		{
+			return overtime;
+		}
+		else
+		{
+			return grace;
+		}
+	}
+}
+
 float CNEORules::GetRoundAccumulatedTime() const
 {
 	return gpGlobals->curtime - (m_flNeoRoundStartTime + sv_neo_preround_freeze_time.GetFloat());
@@ -1622,7 +1718,7 @@ float CNEORules::GetRoundAccumulatedTime() const
 #ifdef GAME_DLL
 float CNEORules::MirrorDamageMultiplier() const
 {
-	if (m_nRoundStatus != NeoRoundStatus::RoundLive)
+	if (!IsRoundLive())
 	{
 		return 0.0f;
 	}
@@ -2414,6 +2510,7 @@ void CNEORules::StartNextRound()
 
 	m_flNeoRoundStartTime = gpGlobals->curtime;
 	m_flNeoNextRoundStartTime = 0;
+	m_flGhostLastHeld = 0;
 
 	CleanUpMap();
 	const bool bFromStarting = (m_nRoundStatus == NeoRoundStatus::Warmup
@@ -2547,12 +2644,12 @@ bool CNEORules::IsRoundOver() const
 
 bool CNEORules::IsRoundLive() const
 {
-	return m_nRoundStatus == NeoRoundStatus::RoundLive;
+	return (m_nRoundStatus == NeoRoundStatus::RoundLive || m_nRoundStatus == NeoRoundStatus::Overtime);
 }
 
 bool CNEORules::IsRoundOn() const
 {
-	return (m_nRoundStatus == NeoRoundStatus::PreRoundFreeze) || (m_nRoundStatus == NeoRoundStatus::RoundLive) || (m_nRoundStatus == NeoRoundStatus::PostRound);
+	return (m_nRoundStatus == NeoRoundStatus::PreRoundFreeze) || IsRoundLive() || (m_nRoundStatus == NeoRoundStatus::PostRound);
 }
 
 void CNEORules::CreateStandardEntities(void)
@@ -3491,7 +3588,7 @@ void CNEORules::CheckIfCapPrevent(CNEO_Player *capPreventerPlayer)
 	// If this is the only player alive left before the suicide/disconnect and the other team was holding
 	// the ghost, reward the other team an XP to the next rank as a ghost cap was prevented.
 	const bool bShouldCheck = (sv_neo_suicide_prevent_cap_punish.GetBool()
-							   && m_nRoundStatus == NeoRoundStatus::RoundLive
+							   && IsRoundLive()
 							   && !m_bTeamBeenAwardedDueToCapPrevent);
 	if (!bShouldCheck)
 	{
@@ -3585,7 +3682,7 @@ void CNEORules::PlayerKilled(CBasePlayer *pVictim, const CTakeDamageInfo &info)
 		{
 			attacker->AddPoints(-1, true);
 #ifdef GAME_DLL
-			if (sv_neo_teamdamage_kick.GetBool() && m_nRoundStatus == NeoRoundStatus::RoundLive)
+			if (sv_neo_teamdamage_kick.GetBool() && IsRoundLive())
 			{
 				++attacker->m_iTeamKillsInflicted;
 			}

src/game/shared/neo/neo_gamerules.h

@@ -108,6 +108,7 @@ enum NeoRoundStatus {
 	Warmup,
 	PreRoundFreeze,
 	RoundLive,
+	Overtime,
 	PostRound,
 	Pause,
 	Countdown,
@@ -258,6 +259,7 @@ class CNEORules : public CHL2MPRules, public CGameEventListener
 	virtual bool CheckGameOver(void) OVERRIDE;
 
 	float GetRoundRemainingTime() const;
+	float GetCTGOverTime() const;
 	float GetRoundAccumulatedTime() const;
 #ifdef GAME_DLL
 	float MirrorDamageMultiplier() const;
@@ -445,6 +447,7 @@ class CNEORules : public CHL2MPRules, public CGameEventListener
 	CNetworkVar(int, m_iGhosterPlayer);
 	CNetworkVector(m_vecGhostMarkerPos);
 	CNetworkVar(bool, m_bGhostExists);
+	CNetworkVar(float, m_flGhostLastHeld);
 
 	// Juggernaut networked variables
 	CNetworkVar(int, m_iJuggernautPlayerIndex);