TM2020-Gamemodes/TM_MultiLivesKnockout.Script.txt

/**
 *	Multi Lives Knockout mode
 */
#Extends "Modes/Nadeo/Trackmania/Base/TrackmaniaRoundsBase.Script.txt"

#Const	CompatibleMapTypes	"TrackMania\\TM_Race,TM_Race"
#Const	Version							"2024-08-27"
#Const	ScriptName					"Modes/TM2020-Gamemodes/TM_MultiLivesKnockout.Script.txt"

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// MARK: Libraries
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
#Include "TextLib" as TL
#Include "MathLib" as ML
#Include "Libs/Nadeo/CMGame/Utils/Semver.Script.txt" as Semver
#Include "Libs/Nadeo/CMGame/Utils/Utils.Script.txt" as CommonUtils
#Include "Libs/Nadeo/Trackmania/Modes/Knockout/StateManager.Script.txt" as StateMgr
#Include "Libs/Nadeo/Trackmania/MainMenu/Constants.Script.txt" as MenuConsts
#Include "Libs/Nadeo/TMGame/Utils/Tracking.Script.txt" as Tracking
#Include "Libs/Nadeo/Trackmania/Modes/Knockout/UIModules/KnockoutInfo_Server.Script.txt" as UIModules_KnockoutInfo
#Include "Libs/Nadeo/Trackmania/Modes/TimeAttack/UIModules/BestRaceViewer_Server.Script.txt" as UIModules_BestRaceViewer
#Include "Libs/Nadeo/Trackmania/Modes/Knockout/UIModules/KnockedOutPlayers_Server.Script.txt" as UIModules_KnockedOutPlayers
#Include "Libs/Nadeo/Trackmania/Modes/Knockout/UIModules/KnockoutReward_Server.Script.txt" as UIModules_KnockoutReward
#Include "Libs/Nadeo/TMGame/Modes/Base/UIModules/PauseMenuOnline_Server.Script.txt" as UIModules_PauseMenu_Online
#Include "Libs/Nadeo/TMGame/Modes/Base/UIModules/Checkpoint_Server.Script.txt" as UIModules_Checkpoint

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// MARK: Settings
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
#Setting S_FinishTimeout 5 as _("Finish timeout")
#Setting S_RoundsPerMap -1 as _("Number of rounds per track") ///< Number of round to play on one map before going to the next one
#Setting S_WarmUpNb 0 as _("Number of warm up")
#Setting S_WarmUpDuration 0 as _("Duration of one warm up")
#Setting S_WarmUpTimeout -1 as _("Warm up timeout")
#Setting S_ChatTime 6
#Setting S_EnableJoinLeaveNotifications False
//L16N [Knockout] Setting for the KO mode, for example if the setting is "4,16,16" it means : "4 players eliminated per round until 16 players are left (16 is written twice, so two extra players are eliminated), then 2 players eliminated per round until 4 players are left (one extra player), then 1 player eliminated per round (default)".
#Setting S_EliminatedPlayersNbRanks "4,16,16" as _("Nb of players above which one extra elim. /round")
#Setting S_RoundsWithoutElimination 1 as _("Rounds without elimination")

#Setting S_EliminatePerRounds False as "Eliminate par rounds instead of per players alive"
#Setting S_MaximumLives 3
#Setting S_MatchName "Final"
#Setting S_AlternativeMatchInfosPosition False


/* About S_EliminatedPlayersNbRanks and S_EliminatePerRounds.
 * If S_EliminatePerRounds is True, it will decrease the number of lose of life.
 * Example : "8,16"
 * Round 1 to 7 -> 3 eliminations per round
 * Round 8 to 15 -> 2 eliminations per round
 * Round 16 until the end -> 1 elimination per round
 *
 * Example : "8,16,16"
 * Round 1 to 7 -> 4 eliminations per round
 * Round 8 to 15 -> 3 eliminations per round
 * Round 16 until the end -> 1 elimination per round
 *
 * Example : "0,8"
 * Round 1 to 7 -> 3 eliminations per round
 * Round 8 until the end -> 1 elimination per round
 *
 * Example : ""
 * 1 elimination per round
 * 
 * If S_EliminatePerRounds is False, it will work like the official 
 */

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// MARK: Constants
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
#Const C_ModeName "Multi Lives Knockout"
//L16N [Knockout] Description of the mode
#Const Description _("$zIn $<$t$6F9Knockout$> mode, the goal is to be the last player standing. \n\nYou play a series of races as in Round mode. $<$t$6F9At the end of each race, the last players are eliminated$>!\n\nThe winner is the player who eliminates all of their opponents.")

#Const C_HudModulePath "" //< Path to the hud module
#Const C_ManiaAppUrl "file://Media/ManiaApps/Nadeo/Trackmania/Modes/Knockout.Script.txt" //< Url of the mania app
#Const C_FakeUsersNb 0

#Const C_Callback_Elimination "Trackmania.Knockout.Elimination"
#Const C_Callback_LostLife "Trackmania.Knockout.LostLife"

#Const C_MlId_LiveRanking "MultiLivesKnockout.LiveRanking"


// [Knockout] Time remaining before the first round begins (in seconds). %1 is a marker to apply typography. %2 is a digit. e.g. "Next round in 3s"
#Const C_Text_NextRoundTimer _("%1Next round in %2s")

#Const C_UploadRecord True
#Const C_DisplayRecordGhost False
#Const C_DisplayRecordMedal False
#Const C_CelebrateRecordGhost True
#Const C_CelebrateRecordMedal True

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// MARK: Structures
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
#Struct K_Callback_Elimination {
	Text[] accountids;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// MARK: Extends
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
***Match_LogVersions***
***
Log::RegisterScript(ScriptName, Version);
Log::RegisterScript(Semver::ScriptName, Semver::Version);
Log::RegisterScript(ModeUtils::ScriptName, ModeUtils::Version);
Log::RegisterScript(StateMgr::ScriptName, StateMgr::Version);
***

***Match_LoadLibraries***
***
// Not used for now but can be useful for players
XmlRpc::RegisterCallback(C_Callback_Elimination, """
* Name: {{{C_Callback_Elimination}}}
* Type: CallbackArray
* Description: Callback sent at the end of each round with the accountid of eliminated players.
* Data:
	- Version >=2.0.0:
	```
	[
		"{
			"accountids": [
				{
					"45b9cf1e-3c97-4753-ac63-ac61b48b4bb7"
				}
			]
		}"
	]
	```
""");
XmlRpc::RegisterCallback(C_Callback_LostLife, """
* Name: {{{C_Callback_LostLife}}}
* Type: CallbackArray
* Description: Callback sent at the end of each round with the accountid of the players who lost a life.
* Data:
	- Version >=2.0.0:
	```
	[
		"{
			"accountids": [
				{
					"45b9cf1e-3c97-4753-ac63-ac61b48b4bb7"
				}
			]
		}"
	]
	```
""");

StateMgr::Load();
***

***Match_UnloadLibraries***
***
StateMgr::Unload();

XmlRpc::UnregisterCallback(C_Callback_Elimination);
XmlRpc::UnregisterCallback(C_Callback_LostLife);
***

***Match_Settings***
***
MB_Settings_UseDefaultHud = (C_HudModulePath == "");
MB_Settings_UseDefaultPodiumSequence = False;
***

***Match_Rules***
***
ModeInfo::SetName(C_ModeName);
ModeInfo::SetType(ModeInfo::C_Type_FreeForAll);
ModeInfo::SetRules(Description);
ModeInfo::SetStatusMessage("");
***

***Match_LoadHud***
***
if (C_HudModulePath != "") Hud_Load(C_HudModulePath);
***

***Match_AfterLoadHud***
***
ClientManiaAppUrl = C_ManiaAppUrl;
Race::SortScores(Race::C_Sort_TotalPoints);
UIModules_TimeGap::SetTimeGapMode(UIModules_TimeGap::C_TimeGapMode_CurRace);
UIModules_PauseMenu_Online::SetHelp(Description);
UIModules_Checkpoint::SetVisibilityTimeDiff(False);
UIModules_Checkpoint::SetRankMode(UIModules_Checkpoint::C_RankMode_CurrentRace);

// Remove Default UI
UIModules::UnloadModules([UIModules_KnockoutReward::C_Id, UIModules_KnockoutInfo::GetId()]);
LoadManialinks();
***

***Match_Yield***
***
foreach (Event in PendingEvents) {
	switch (Event.Type) {
		// Initialize players when they join the server
		case CSmModeEvent::EType::OnPlayerAdded: {
			StateMgr::InitializePlayer(Event.Player);
			CarRank::InitializePlayer(Event.Player);
		}
	}
}

// Manage XmlRpc events
/**
 * "Club.Match." callbacks are used by the official competition tool. Not used in community modes.
 */
/*foreach (Event in XmlRpc.PendingEvents) {
	if (Event.Type == CXmlRpcEvent::EType::CallbackArray) {
		if (Event.ParamArray1 == "Club.Match.Start") {
			declare Boolean Match_SkipWarmup for This = False;
			Match_SkipWarmup = True;
		} else if (Event.ParamArray1 == "Club.Match.Completed") {
			declare Boolean Match_SkipWarmup for This = False;
			Match_SkipWarmup = False;
		}
	}
}*/

StateMgr::Yield();
***

***Match_StartServer***
***
// Initialize mode
Clans::SetClansNb(0);
Scores::SaveInScore(Scores::C_Points_Match);
StateMgr::ForcePlayersStates([StateMgr::C_State_Waiting]);
WarmUp::SetAvailability(True);

Race::SetupRecord(
	MenuConsts::C_ScopeType_Season,
	MenuConsts::C_ScopeType_PersonalBest,
	MenuConsts::C_GameMode_Knockout,
	"",
	C_UploadRecord,
	C_DisplayRecordGhost,
	C_DisplayRecordMedal,
	C_CelebrateRecordGhost,
	C_CelebrateRecordMedal
);
Race::UseAutomaticDossardColor(False);
***

***Match_InitMatch***
***
declare Integer Match_CurrentRoundNb;
declare Boolean Match_RegistrationIsOpen;

***

***Match_StartMatch***
***
Match_CurrentRoundNb = 0;
Match_RegistrationIsOpen = True;

foreach (Score in Scores) {
	declare netwrite Boolean Net_MultiLivesKnockout_IsRegistered for Score;
	Net_MultiLivesKnockout_IsRegistered = False;

	declare netwrite Integer Net_MultiLivesKnockout_ConsumedLives for Score;
	Net_MultiLivesKnockout_ConsumedLives = 0;
}
UpdateCustomRanking(False);
DisplayLiveRanking(False);
***

***Match_InitMap***
***
UpdateMatchInfos(Match_CurrentRoundNb);
UpdateCustomRanking(False);
UIModules_ScoresTable::SetScoreMode(UIModules_ScoresTable::C_Mode_PrevTime);
***

***Match_StartMap***
***
// Add bot when necessary
Users_SetNbFakeUsers(C_FakeUsersNb, 0);

CarRank::Reset();

// Warm up
if (S_WarmUpNb > 0) {
	UpdateInterfacesInfo(-1);	
	foreach (Score in Scores) {
		WarmUp::CanPlay(Score, (Match_RegistrationIsOpen || ScoreIsAlive(Score)));
	}

	MB_WarmUp(S_WarmUpNb, S_WarmUpDuration * 1000, S_WarmUpTimeout * 1000);
	UpdateInterfacesInfo(Match_CurrentRoundNb);	
}

UpdateCustomRanking(False);
***

***Match_InitRound***
***
declare Integer Round_LossOfLifeNb;
declare Boolean Round_NeedInfoDisplayUpdate;
***

***Rounds_CanSpawn***
***
// Register new players while registration are open
if (Match_RegistrationIsOpen) {
	foreach(Player in Players) {
		if (!ScoreIsRegistered(Player.Score)) RegisterScore(Player.Score);
	}
}

Match_CurrentRoundNb += 1;
declare Integer AliveScoresNb = GetAliveScoresNb();
Round_LossOfLifeNb = GetLossOfLifeNb(Match_CurrentRoundNb, AliveScoresNb);
if (Round_LossOfLifeNb <= 0) {
	CarRank::ResetRanksColors();
} else {
	CarRank::SetRanksColors([
		1 => Race::C_DossardColor_Default,
		AliveScoresNb - Round_LossOfLifeNb + 1 => <0.7, 0., 0.>
	]);
}

UpdateInterfacesInfo(Match_CurrentRoundNb, Round_LossOfLifeNb, AliveScoresNb);

declare Text ObjectiveMessage = "";
if (Round_LossOfLifeNb > 1) {
	//L16N [Knockout] Announce the number of players that will be eliminated at the end of the round. %1 will be replaced by a number greater than 1. eg: "2 players will be eliminated".
	ObjectiveMessage = TL::Compose("%1 players will lose a life", "$t$i$fff"^TL::ToText(Round_LossOfLifeNb));
} else if (Round_LossOfLifeNb == 1){
	//L16N [Knockout] Announce the number of players that will be eliminated at the end of the round. %1 will be replaced by the digit 1. eg: "1 player will be eliminated".
	ObjectiveMessage = TL::Compose("%1 player will lose a life", "$t$i$fff"^TL::ToText(Round_LossOfLifeNb));
} else {
	//L16N [Knockout] Announce the number of players that will be eliminated at the end of the round. %1 will be replaced by a marker for Typography
	ObjectiveMessage = TL::Compose("%1No loss of life this round", "$t$i$fff");
}
UIModules_BigMessage::SetMessage(ObjectiveMessage, 5500);
UIModules_BigMessage::SetOffset(<0., -40.>);

// Knockout 3, 2, 1
UIManager.UIAll.BigMessageSound = CUIConfig::EUISound::Default;
UIManager.UIAll.BigMessageSoundVariant = 0;
MB_Sleep(1000);
UIManager.UIAll.BigMessage = TL::Compose(C_Text_NextRoundTimer, "$i$t", "3");
MB_Sleep(1000);
UIManager.UIAll.BigMessage = TL::Compose(C_Text_NextRoundTimer, "$i$t", "2");
MB_Sleep(1000);
UIManager.UIAll.BigMessage = TL::Compose(C_Text_NextRoundTimer, "$i$t", "1");
MB_Sleep(1000);
UIManager.UIAll.BigMessage = "";
StartTime = Now + Race::C_SpawnDuration;

// Set spawn permission
foreach (Score in Scores) {
	declare Boolean ModeRounds_CanSpawn for Score = True;
	ModeRounds_CanSpawn = ScoreIsAlive(Score);
}
***

***Match_StartRound***
***
// Update UI
UIModules_BestRaceViewer::SetPrevDisplay(False);

UpdateLiveRanking();
DisplayLiveRanking(True);
UpdateCustomRanking(True);
UpdateInterfacesInfo(Match_CurrentRoundNb);
Round_NeedInfoDisplayUpdate = False;

StateMgr::ForcePlayersStates([StateMgr::C_State_Playing]);
***

***Rounds_PlayerSpawned***
***
CarRank::ThrottleUpdate(CarRank::C_SortCriteria_CurrentRace);
***

***Rounds_PlayLoopSpawnPlayers***
***
// Spawn allowed players
foreach (Player in Players) {
	if (Player.Score == Null) continue;

	declare Boolean ModeRounds_CanSpawn for Player.Score = True;

	if (Match_RegistrationIsOpen && !ScoreIsRegistered(Player.Score)) {
		RegisterScore(Player.Score);
		ModeRounds_CanSpawn = ScoreIsAlive(Player.Score);
	}

	if (MB_RoundIsRunning() && Race::IsReadyToStart(Player) && ModeRounds_CanSpawn && ScoreIsAlive(Player.Score)) {
		Race::Start(Player, StartTime);
		ModeRounds_CanSpawn = False;
		Round_NeedInfoDisplayUpdate = True;	
		+++Rounds_PlayerSpawned+++
	}
}
if (Round_NeedInfoDisplayUpdate) {
	UpdateCustomRanking(True);
	UpdateInterfacesInfo(Match_CurrentRoundNb);
	Round_NeedInfoDisplayUpdate = False;
}
***

***Match_PlayLoop***
***
foreach (Event in PendingEvents) {
	if (Event.Type == CSmModeEvent::EType::OnPlayerAdded) {
		if (Event.Player != Null) {
			UIModules_BestRaceViewer::SetPrevDisplay(Event.Player, False);
		}
	}
}

// Manage race events
declare Events::K_RaceEvent[] RacePendingEvents = Race::GetPendingEvents();
foreach (Event in RacePendingEvents) {
	Race::ValidEvent(Event);
	UpdateLiveRanking();

	// Waypoint
	if (Event.Type == Events::C_Type_Waypoint) {
		CarRank::ThrottleUpdate(CarRank::C_SortCriteria_CurrentRace);
		if (Event.Player != Null) {
			if (Event.IsEndRace) {
				Scores::UpdatePlayerPrevRace(Event.Player);
				Scores::UpdatePlayerBestRaceIfBetter(Event.Player);
				Scores::UpdatePlayerBestLapIfBetter(Event.Player);

				// Start the countdown if it's the first player to finish
				if (EndTime <= 0) {
					EndTime = GetFinishTimeout();
				}

				UIModules_BestRaceViewer::SetPrevDisplay(Event.Player, True);
				UpdateCustomRanking(True);
			}
			if (Event.IsEndLap) {
				Scores::UpdatePlayerBestLapIfBetter(Event.Player);
			}
		}
	}
}

// Manage mode events
foreach (Event in PendingEvents) {
	if (Event.HasBeenPassed || Event.HasBeenDiscarded) continue;
	Events::Invalid(Event);
}
***

***Match_EndRound***
***
Race::StopSkipOutroAll();
EndTime = -1;
StateMgr::ForcePlayersStates([StateMgr::C_State_Waiting]);
CarRank::Update(CarRank::C_SortCriteria_CurrentRace);

if (Semver::Compare(XmlRpc::GetApiVersion(), ">=", "2.1.1")) {
	Scores::XmlRpc_SendScores(Scores::C_Section_PreEndRound, "");
}

declare Text[] LostLifeAccountIds;
declare Text[] EliminatedAccountIds;
declare Integer[] EliminatedRanks;

if (Round_ForceEndRound || Round_SkipPauseRound) {
	// Cancel points
	foreach (Score in Scores) {
		Scores::SetPlayerRoundPoints(Score, 0);
	}
	// Do not launch the forced end round sequence after a pause
	if (!Round_SkipPauseRound) {
		ForcedEndRoundSequence();
	}
	MB_SetValidRound(False);
} else {
	// Eliminate players that did not finish in time
	declare Ident[] EliminatedPlayersScoresIds = []; // Score.Id

	if (Match_CurrentRoundNb > S_RoundsWithoutElimination) {
		// Close registrations. Players can join the game any time during no elimination rounds
		Match_RegistrationIsOpen = False;

		// Eliminate last players
		declare Integer ParticipantsNb = GetParticipantsNb();
		declare Integer AliveScoresNb = GetAliveScoresNb();
		declare Integer LossOfLifeNb = GetLossOfLifeNb(Match_CurrentRoundNb, AliveScoresNb);
		declare Integer Rank = AliveScoresNb;
		
		foreach (Score in GetPrevRaceRanking() reverse) {
			if (Score.User == Null) continue;
			if (!ScoreIsAlive(Score)) continue;
			if (Scores::GetPlayerPrevRaceTime(Score) > 0 && LossOfLifeNb <= 0) {
				break;
			}

			ConsumeLife(Score);
			LostLifeAccountIds.add(Score.User.WebServicesUserId);

			if (!ScoreIsAlive(Score)) {
				Scores::SetPlayerMatchPoints(Score, ParticipantsNb - Rank);
				EliminatedAccountIds.add(Score.User.WebServicesUserId);
				EliminatedRanks.add(Rank);

				Rank -= 1;
			}
			
			LossOfLifeNb -= 1;
		}
	}

	declare K_Callback_Elimination Callback_LostLife;
	foreach(AccountId in LostLifeAccountIds) {
		Callback_LostLife.accountids.add(AccountId);
	}
	XmlRpc::SendCallback(C_Callback_LostLife, [Callback_LostLife.tojson()]);


	// Send Trophies, uses EliminatedAccountIds array
	+++Match_EndRound_AfterComputeScores+++

	UpdateCustomRanking(True);
	UpdateMatchInfos(Match_CurrentRoundNb);

	// The UI display "no elimination during the FIRST round" when no elimination. So to prevent confusion, i disable it
	if (EliminatedAccountIds.count > 0) {
		UIModules_KnockedOutPlayers::DisplayContent(True);
		UIModules_KnockedOutPlayers::DisplayEliminatedPlayer(EliminatedAccountIds, EliminatedRanks);
		declare Integer PagesToShow = EliminatedAccountIds.count/4;
		if (EliminatedAccountIds.count%4 != 0) PagesToShow += 1;
		MB_Sleep(ML::Max(1100 + 350*EliminatedAccountIds.count + 1600*PagesToShow + 250, 6000 + 250));
		UIModules_KnockedOutPlayers::DisplayEliminatedPlayer([], []);
		UIModules_KnockedOutPlayers::DisplayContent(False);
		declare K_Callback_Elimination Callback_Elimination;
		foreach(AccountId in EliminatedAccountIds) {
			Callback_Elimination.accountids.add(AccountId);
		}
		XmlRpc::SendCallback(C_Callback_Elimination, [Callback_Elimination.tojson()]);
	}

	if (MapIsOver(Match_CurrentRoundNb)) {
		MB_StopMap();
	} else {
		UIManager.UIAll.ScoreTableVisibility = CUIConfig::EVisibility::ForcedVisible;
		MB_Sleep(S_ChatTime / 2 * 1000);
		UpdateCustomRanking(False);
		MB_Sleep(S_ChatTime / 2 * 1000);
		UIManager.UIAll.ScoreTableVisibility = CUIConfig::EVisibility::Normal;
	}
	DisplayLiveRanking(False);
}
***

***Match_EndMap***
***
if (MatchIsOver(Match_CurrentRoundNb)) {
	MB_StopMatch();
} else {
	MB_Sleep(2500);
}

if (!MB_MapIsRunning() && MB_MatchIsRunning()) MB_SkipPodiumSequence();

Race::SortScores(Race::C_Sort_TotalPoints);
Scores::SetPlayerWinner(Scores::GetBestPlayer(Scores::C_Sort_MatchPoints));
***

***Match_PodiumSequence***
***
if (!MB_Private_SkipPodiumSequence) {
	ModeUtils::PlaySound(CUIConfig::EUISound::EndRound, 0);

	declare CSmScore WinnerScore <=> Scores::GetPlayerWinner();
	if (WinnerScore == Null) {
		UIModules_BigMessage::SetMessage(_("|Match|Draw"));
	} else {
		UIModules_BigMessage::SetMessage(_("$<%1$> wins the match!"), WinnerScore.User.WebServicesUserId);
	}

	declare CUIConfig::EUISequence PrevUISequence = UIManager.UIAll.UISequence;
	UIManager.UIAll.UISequence = CUIConfig::EUISequence::Podium;
	MB_Private_Sleep(10000);
	UIModules_BigMessage::SetMessage("");
	UIManager.UIAll.ScoreTableVisibility = CUIConfig::EVisibility::ForcedVisible;
	MB_Private_Sleep((S_ChatTime*1000));
	UIManager.UIAll.ScoreTableVisibility = CUIConfig::EVisibility::Normal;
	UIManager.UIAll.UISequence = PrevUISequence;
}
***

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// MARK: Functions
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Init player at the beginning of the match
 *
 *	@param	_Player							Player to init
 */
Void RegisterScore(CSmScore _Score) {
	declare netwrite Boolean Net_MultiLivesKnockout_IsRegistered for _Score;
	Net_MultiLivesKnockout_IsRegistered = True;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Whether the player is registered or not
 *
 *	@return									True if the player is registered
 *													False Otherwise
 */
Boolean ScoreIsRegistered(CSmScore _Score) {
	declare netwrite Boolean Net_MultiLivesKnockout_IsRegistered for _Score;
	return Net_MultiLivesKnockout_IsRegistered;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Whether the player has been eliminated or not
 *
 *	@return									True if the player has been eliminated
 *													False Otherwise
 */
Boolean ScoreIsAlive(CSmScore _Score) {
	if (_Score == Null) return False;

	if (!ScoreIsRegistered(_Score)) return False;

	declare netwrite Integer Net_MultiLivesKnockout_ConsumedLives for _Score;
	if (Net_MultiLivesKnockout_ConsumedLives >= S_MaximumLives) return False;

	return True;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Number of scores registred
 *
 *  @param														_Score
 *	@return														Number of Lives
 */
Integer GetScoreRemainingLives(CSmScore _Score) {
	if (_Score == Null) return 0;
	if (!ScoreIsAlive(_Score)) return 0;

	declare netwrite Integer Net_MultiLivesKnockout_ConsumedLives for _Score;
	return S_MaximumLives - Net_MultiLivesKnockout_ConsumedLives;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Consume life of a Score
 *
 *	@param														_Score
 */
Void ConsumeLife(CSmScore _Score) {
	if (_Score == Null) return;
	declare netwrite Integer Net_MultiLivesKnockout_ConsumedLives for _Score;
	Net_MultiLivesKnockout_ConsumedLives += 1;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Number of scores registred
 *
 *	@return														Number of scores registred
 */
Integer GetParticipantsNb() {
	declare Integer ParticipantsNb;
	foreach (Score in Scores) {
		if (!ScoreIsRegistered(Score)) continue;

		ParticipantsNb += 1;
	}
	return ParticipantsNb;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Number of players still playing
 *
 *	@return														Number of players still playing
 */
Integer GetAliveScoresNb() {
	declare Integer AliveScoresNb;
	foreach (Score in Scores) {
		if (!ScoreIsAlive(Score)) continue;

		AliveScoresNb += 1;
	}
	return AliveScoresNb;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Compute Lose of Life Milestones
 *
 *	@return														Array of each milestone
 */
Integer[] GetAllMilestones() {
	declare Text[] Text_Milestones = TL::Split(",", S_EliminatedPlayersNbRanks);
	declare Integer[] Milestones = [ 1 ];
	foreach (Text_Milestone in Text_Milestones) {
		declare Integer Milestone = TL::ToInteger(Text_Milestone);
		if (Milestone > 0) Milestones.add(Milestone);
		else if (Milestone == 0) Milestones.add(1);
	}
	return Milestones;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Get next milestone of loss of life
 *
 *	@param	_RoundNb									Round Number
 *	@param	_AliveScoresNb						Number of players still playing
 *	@return														next milestone value
 */
Integer GetNextMilestone(Integer _RoundNb, Integer _AliveScoresNb) {
	if (_AliveScoresNb <= 0) return 0;
	declare Integer[] Milestones = GetAllMilestones();

	declare Integer NextMilestone = 0;
	foreach (Milestone in Milestones) {
		if (S_EliminatePerRounds && Milestone > _RoundNb) {
			NextMilestone = Milestone;
			break;
		} else if (!S_EliminatePerRounds && Milestone < _AliveScoresNb) { // could be optimized but can change original behavior
			NextMilestone = Milestone;
		}
	}
	return NextMilestone;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Number of players that will lose a life this round
 *
 *	@param	_RoundNb									Round Number
 *	@param	_AliveScoresNb						Number of players still playing
 *	@return														Number of eliminations this round
 */
Integer GetLossOfLifeNb(Integer _RoundNb, Integer _AliveScoresNb) {
	if (_AliveScoresNb <= 1) return 0;
	if (_RoundNb <= S_RoundsWithoutElimination) return 0;
	declare Integer[] Milestones = GetAllMilestones();

	declare Integer NumberOfElimination;

	if (S_EliminatePerRounds) {
		Milestones = Milestones.slice(1);
		NumberOfElimination = 1;
		foreach (Milestone in Milestones) {
			if (Milestone > _RoundNb) {
				NumberOfElimination += 1;
			}
		}
	} else {
		declare Integer RoundMinEliminations = Milestones.count + 1;
		foreach (Index => Milestone in Milestones) {
			if (Milestone < _AliveScoresNb) {
				RoundMinEliminations = Index + 1;
			}
		}
		NumberOfElimination = RoundMinEliminations;
	}

	return ML::Min(NumberOfElimination, _AliveScoresNb-1);
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/// Get the scores ranked by previous race time
CSmScore[] GetPrevRaceRanking() {
	declare Integer[][Ident] ScoreIdsToSortByWaypointTimes;
	foreach (Score in Scores) {
		ScoreIdsToSortByWaypointTimes[Score.Id] = CommonUtils::ToScriptArray(Score.PrevRaceTimes);
	}

	declare Ident[][Integer] ScoreIdsSortedByWaypointTimes = Scores::SortIdsByWaypointTimes(ScoreIdsToSortByWaypointTimes);
	declare CSmScore[] SortedScores;
	foreach (WaypointTimesScoreIds in ScoreIdsSortedByWaypointTimes) {
		declare Ident[][] ScoreIdsSortedByPoints;
		if (WaypointTimesScoreIds.count <= 1) {
			ScoreIdsSortedByPoints = [WaypointTimesScoreIds];
		} else {
			declare Integer[Ident] ScoreIdsToSortByPoints;
			foreach (ScoreId in WaypointTimesScoreIds) {
				ScoreIdsToSortByPoints[ScoreId] = Scores::GetPlayerMatchPoints(Scores[ScoreId]);
			}
			ScoreIdsSortedByPoints = Scores::SortIdsByPoints(ScoreIdsToSortByPoints, Scores::C_Order_Descending, 0);
		}
		foreach (PointsScoreIds in ScoreIdsSortedByPoints) {
			foreach (ScoreId in PointsScoreIds) {
				SortedScores.add(Scores[ScoreId]);
			}
		}
	}

	return SortedScores;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Return the number of the remaining lives in text format, with heart symbol if possible
 *
 *	@param	_Score								Player's score
 *	@return												True if player finished race
 */
Text GetScoreRemainingLivesText(CSmScore _Score) {
	declare Integer RemainingLives = GetScoreRemainingLives(_Score);

	// Use text if too much lives
	if (S_MaximumLives > 5) {
		if (RemainingLives == 1) return "1 life";
		else return RemainingLives ^" lives";
	}

	declare Text Result = " ";
	for (I, 1, S_MaximumLives - RemainingLives) {
		Result ^= " ";
	}

	for (I, 1, RemainingLives) {
		Result ^= " ";
	}

	/*
	 * To reduce height of the hearts symbols, we add spaces around them to make the length of the CMlText too long,
	 * to force the ScoresTable ML to fit the text. It's weird but it's pretty.
	 */
	switch (TL::Length(Result)) {
		case 3: Result  = "             "^ Result ^"             ";
		case 5: Result  = "          "^ Result ^"          ";
		case 7: Result  = "        "^ Result ^"        ";
		case 9: Result  = "      "^ Result ^"      ";
		case 11: Result = "   "^ Result ^"   ";
	}

	return Result;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Update the Scores Table with hidden custom points
 *
 *	@param	_DisplayTimes							Display Player Time instead of their Lives
 */
Void UpdateCustomRanking(Boolean _DisplayTimes) {
	declare Text[] AccountIdsToDisplay = [];
	declare Text[][Text] CustomPoints = [];

	declare Integer ParticipantsNb = GetParticipantsNb();
	declare Integer AliveScoresNb = GetAliveScoresNb();

	foreach (Index => Score in GetPrevRaceRanking() reverse) {
		if (Score == Null) continue;
		if (Score.User == Null) continue;
		if (!ScoreIsRegistered(Score)) continue;
		AccountIdsToDisplay.add(Score.User.WebServicesUserId);
		if (!ScoreIsAlive(Score)) continue;
		
		if (_DisplayTimes) {
			Scores::SetPlayerMatchPoints(Score, ParticipantsNb + ParticipantsNb - Index); 
		} else {
			Scores::SetPlayerMatchPoints(Score, ParticipantsNb + GetScoreRemainingLives(Score)); 
			CustomPoints[Score.User.WebServicesUserId] = [GetScoreRemainingLivesText(Score)];
		}
		if (AliveScoresNb == 1 && ParticipantsNb > 1) {
			CustomPoints[Score.User.WebServicesUserId] = [_("|Status|Winner"), "0f0"];
		}
	}

	declare Integer Rank = 1;
	declare Text[Text] CustomRanks = [];
	Race::SortScores(Race::C_Sort_TotalPoints);
	foreach (Score in Scores) {
		if (AliveScoresNb == 1 && ScoreIsAlive(Score)) {
			CustomRanks[Score.User.WebServicesUserId] = "1";
		} else if (ScoreIsAlive(Score)) {
			CustomRanks[Score.User.WebServicesUserId] = "-";
		}	else if (ScoreIsRegistered(Score)) {
			CustomRanks[Score.User.WebServicesUserId] = ""^Rank;
			CustomPoints[Score.User.WebServicesUserId] = [_("|Status|K.O."), "f00"];
		}
		Rank += 1;
	}

	UIModules_ScoresTable::SetCustomRanks(CustomRanks);
	UIModules_ScoresTable::DisplayOnly(AccountIdsToDisplay); // Display only registered players
	UIModules_ScoresTable::SetCustomPoints(CustomPoints);
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Get the time left to the players to finish the round after the first player
 *
 *	@return 		The time left in ms
 */
Integer GetFinishTimeout() {
	declare Integer FinishTimeout = 0;

	if (S_FinishTimeout >= 0) {
		FinishTimeout = S_FinishTimeout * 1000;
	} else {
		FinishTimeout = 5000;
		if (Map.TMObjective_IsLapRace && Race::GetLapsNb() > 0 && Map.TMObjective_NbLaps > 0) {
			FinishTimeout += ((Map.TMObjective_AuthorTime / Map.TMObjective_NbLaps) * Race::GetLapsNb()) / 6;
		} else {
			FinishTimeout += Map.TMObjective_AuthorTime / 6;
		}
	}

	return Now + FinishTimeout;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Check if we should go to the next match
 *
 *	@param _RoundNb		Current round number
 *	@return						True if it is the case, false otherwise
 */
Boolean MatchIsOver(Integer _RoundNb) {
	if (_RoundNb <= S_RoundsWithoutElimination || GetAliveScoresNb() > 1) return False;

	return True;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Check if we should go to the next map
 *
 *	@param _RoundNb		Current round number
 *	@return						True if it is the case, false otherwise
 */
Boolean MapIsOver(Integer _RoundNb) {
	if (MatchIsOver(_RoundNb)) return True;
	if (S_RoundsPerMap > 0 && MB_GetRoundCount() >= S_RoundsPerMap) return True; //< There is a rounds limit and it is reached

	return False;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/// Update LiveRanking
Void UpdateLiveRanking() {
	declare netwrite Integer Net_MultiLivesKnockout_LiveRanking_Serial for Teams[0];
	Net_MultiLivesKnockout_LiveRanking_Serial += 1;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/// Update LiveRanking Info
Void UpdateLiveRankingInfo() {
	declare netwrite Integer Net_MultiLivesKnockout_LiveRanking_Info_Serial for Teams[0];
	Net_MultiLivesKnockout_LiveRanking_Info_Serial += 1;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/// Update LiveRanking
Void DisplayLiveRanking(Boolean _Display) {
	declare netwrite Boolean Net_MultiLivesKnockout_LiveRanking_Display for Teams[0] = False;
	Net_MultiLivesKnockout_LiveRanking_Display = _Display;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Update the Match Info UI and scores table footer text
 *
 *	@param	_CurrentRoundNb							Current Round Number
 *	@param	_LossOfLife									Number of loss of life
 *	@param	_AliveScoresNb							Number of Alive scores
 *	@param	_Milestone									Next Milestone
 */
Void UpdateMatchInfos(Integer _CurrentRoundNb, Integer _LossOfLife, Integer _AliveScoresNb, Integer _Milestone) {
	declare Text MatchInfo = "";
	declare Text ScoreTablesInfo = "";
	if (MatchIsOver(_CurrentRoundNb)) {
		MatchInfo = _("Match is over");
		ScoreTablesInfo = _("Match is over");
	} else {
		ScoreTablesInfo = _AliveScoresNb ^" Players racing";


		if (S_RoundsPerMap > 0) {
			declare Integer MapNumber = MB_GetMapCount() % MapList.count;
			if (MapNumber == 0) MapNumber = 3;

			if (_CurrentRoundNb == -1) MatchInfo = "Warm Up";
			else if (S_EliminatePerRounds) MatchInfo = "Match Round "^ _CurrentRoundNb ^ " - Round "^ ML::Max(MB_GetRoundCount(), 1) ^"/"^ S_RoundsPerMap ^" of Map "^ MapNumber ^"/"^ MapList.count;
			else MatchInfo = "Round "^ ML::Max(MB_GetRoundCount(), 1) ^"/"^ S_RoundsPerMap ^ " - Map "^ MapNumber ^"/"^ MapList.count;
		} else if (_CurrentRoundNb == -1) {
			MatchInfo = "Warm Up";
		} else {
			MatchInfo = "Round "^ ML::Max(_CurrentRoundNb, 1);
		}
		ScoreTablesInfo ^= "\n"^ MatchInfo;

		if (_LossOfLife == 0) {
			MatchInfo ^= "\nNo loss of life";
			ScoreTablesInfo ^= "\nNo loss of life this round";
		} else if (S_EliminatePerRounds && _LossOfLife > 1 && _Milestone > 1) {
			MatchInfo ^= "\n"^ _LossOfLife ^" lives lost until Match Round "^ _Milestone;
			ScoreTablesInfo ^= "\n"^ _LossOfLife ^" players will lose a life until Match Round "^ _Milestone;
		} else if (!S_EliminatePerRounds && _LossOfLife > 1 && _Milestone > 1) {
			MatchInfo ^= "\n"^ _LossOfLife ^" lives lost until "^ _Milestone ^" players are alive";
			ScoreTablesInfo ^= "\n"^ _LossOfLife ^" players will lose a life until "^ _Milestone ^" players are alive";
		} else if (_LossOfLife > 1) {
			MatchInfo ^= "\n"^ _LossOfLife ^" players will lose a life";
			ScoreTablesInfo ^= "\n"^ _LossOfLife ^" players will lose a life per round";
		} else {
			MatchInfo ^= "\n1 player will lose a life";
			ScoreTablesInfo ^= "\n1 player will lose a life";
		}
	}

	UIModules_ScoresTable::SetFooterInfo(ScoreTablesInfo);

	declare netwrite Text Net_MultiLivesKnockout_LiveRanking_MatchInfo for Teams[0];
	Net_MultiLivesKnockout_LiveRanking_MatchInfo = MatchInfo;

	UpdateLiveRankingInfo();
}

Void UpdateMatchInfos(Integer _CurrentRoundNb) {
	declare Integer AliveScoresNb = GetAliveScoresNb();
	UpdateMatchInfos(_CurrentRoundNb, GetLossOfLifeNb(_CurrentRoundNb, AliveScoresNb), AliveScoresNb, GetNextMilestone(_CurrentRoundNb, AliveScoresNb));
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// Update Match Name
Void UpdateMatchName() {
	declare netwrite Text Net_MultiLivesKnockout_LiveRanking_MatchName for Teams[0];
	Net_MultiLivesKnockout_LiveRanking_MatchName = S_MatchName;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// Update Match Infos 
Void UpdateMatchInfosPosition() {
	declare netwrite Boolean Net_MultiLivesKnockout_AlternativePosition for Teams[0];
	Net_MultiLivesKnockout_AlternativePosition = S_AlternativeMatchInfosPosition;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// Update Number of lives
Void UpdateMaximumLives() {
	declare netwrite Integer Net_MultiLivesKnockout_LiveRanking_MaximumLives for Teams[0];
	Net_MultiLivesKnockout_LiveRanking_MaximumLives = S_MaximumLives;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Update number of loss of life
 *
 *	@param	_LossOfLife							Number of loss of life
 */
Void UpdateLossOfLife(Integer _LossOfLife) {
	declare netwrite Integer Net_MultiLivesKnockout_LiveRanking_LossOfLife for Teams[0];
	Net_MultiLivesKnockout_LiveRanking_LossOfLife = _LossOfLife;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Update all the interfaces info
 *
 *	@param	_CurrentRoundNb								Current Round Number
 *	@param	_LossOfLife										Number of loss of life
 *	@param	_AliveScoresNb								Number of Alive scores
 */
Void UpdateInterfacesInfo(Integer _CurrentRoundNb, Integer _LossOfLife, Integer _AliveScoresNb) {
	UpdateMatchInfos(_CurrentRoundNb, _LossOfLife, _AliveScoresNb, GetNextMilestone(_CurrentRoundNb, _AliveScoresNb));
	UpdateMatchInfosPosition();
	UpdateMatchName();
	UpdateMaximumLives();
	UpdateLossOfLife(_LossOfLife);

	UpdateLiveRankingInfo();
}
Void UpdateInterfacesInfo(Integer _CurrentRoundNb) {
	declare Integer AliveScoresNb = GetAliveScoresNb();
	UpdateInterfacesInfo(_CurrentRoundNb, GetLossOfLifeNb(_CurrentRoundNb, AliveScoresNb), AliveScoresNb);
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/// Load Manialinks
Void LoadManialinks() {
	declare Text MLText = """
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<manialink version="3" name="{{{C_MlId_LiveRanking}}}">
<framemodel id="framemodel-player">
	<quad id="quad-player-button" pos="0 0" size="55 5" opacity="0" scriptevents="1"/>
	<quad id="quad-player-selector" pos="0 0" size="42.8 4.8" opacity="0" bgcolor="ffffff"/>
	<label id="label-player-rank" pos="3 -2.1" z-index="2" size="5 5" halign="center" valign="center" textsize="1.5" textfont="GameFontSemiBold" textcolor="dedede"/>
	<label id="label-player-name" pos="6 -2.1" z-index="2" size="27 5"  halign="left" valign="center" textsize="1.5" textfont="GameFontExtraBold" textcolor="ffffff"/>
	<label id="label-player-lives" pos="42 -2.5" z-index="2" size="10 5"  halign="right" valign="center" textsize="0.8" textfont="GameFontExtraBold" textcolor="dedede"/>
	<quad id="quad-player-time-background" pos="55 0" size="12 4.8" halign="right" bgcolor="ffffff" opacity="0.2"/>
	<label id="label-player-time" pos="54 -2" z-index="2" size="10 5" halign="right" valign="center" textsize="2" textfont="Nadeo/Trackmania/BebasNeueRegular" textcolor="ffffff"/>
</framemodel>
<frame id="frame-global" hidden="1">
	<frame id="frame-matchinfo" pos="-160 80" hidden="1">
		<quad size="55 18" bgcolor="000000" opacity="0.6"/>
		<label id="label-matchinfo-name" pos="3 -7.8" size="49 6" valign="bottom" textsize="3.5" textfont="GameFontExtraBold" textcolor="ffffff" text=""/>
		<label id="label-matchinfo-info" pos="3 -8.8" size="49 8" textsize="1.3" maxline="2" linespacing="1.1" textfont="GameFontSemiBold" textcolor="ffffff" text="" />
	</frame>
	<frame id="frame-liveranking" pos="-160 30" size="65 90" hidden="1">
		<frame pos="55 0">
			<quad id="quad-liveranking-togglebutton" pos="0 0" size="4 4" z-index="3" opacity="0.9" colorize="ffffff" scriptevents="1"/>
		</frame>
		<frame id="frame-liveranking-content">
			<quad id="quad-liveranking-background" size="55 12" bgcolor="000000" opacity="0.6"/>
			<label pos="27.5 -3" halign="center" textsize="2.5" textfont="GameFontExtraBold" textcolor="ffffff" text="LIVE RANKING"/>
			<frame id="frame-liveranking-players" pos="0 -10">
				<frameinstance pos="0 0" modelid="framemodel-player" hidden="1"/>
				<frameinstance pos="0 -5" modelid="framemodel-player" hidden="1"/>
				<frameinstance pos="0 -10" modelid="framemodel-player" hidden="1"/>
				<frameinstance pos="0 -15" modelid="framemodel-player" hidden="1"/>
				<frameinstance pos="0 -20" modelid="framemodel-player" hidden="1"/>
				<frameinstance pos="0 -25" modelid="framemodel-player" hidden="1"/>
				<frameinstance pos="0 -30" modelid="framemodel-player" hidden="1"/>
				<frameinstance pos="0 -35" modelid="framemodel-player" hidden="1"/>
				<frameinstance pos="0 -40" modelid="framemodel-player" hidden="1"/>
				<frameinstance pos="0 -45" modelid="framemodel-player" hidden="1"/>
				<frameinstance pos="0 -50" modelid="framemodel-player" hidden="1"/>
				<frameinstance pos="0 -55" modelid="framemodel-player" hidden="1"/>
			</frame>
		</frame>
	</frame>
</frame>
<script><!--
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// MARK: Libraries
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
#Include "TextLib" as TL
#Include "MathLib" as ML
#Include "Libs/Nadeo/CMGame/Utils/Icons.Script.txt" as Icons
#Include "Libs/Nadeo/CMGame/Utils/Tools.Script.txt" as Tools
#Include "Libs/Nadeo/TMGame/Modes/Base/UIModules/WarmupHelpers_Client.Script.txt" as WarmupHelpers
#Include "Libs/Nadeo/Trackmania/Modes/Knockout/Components/EliminationStatus.Script.txt" as EliminationStatus

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// MARK: Constants
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
#Const ScriptName {{{dump(C_MlId_LiveRanking)}}}
#Const Version {{{dump(Version)}}}

#Const C_LinesNb_Top 3

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// MARK: Structures
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
#Struct K_PlayerState {
	Ident ScoreId;
	Text Login;
	Text Name;
	Integer Rank;
	Integer CPNb;
	Integer LastCPTime;
	Integer RaceTime;
	Integer Delta;
	Integer Lives;
	Boolean InDanger;
	Boolean IsNotPlaying;
	Boolean Finished;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// MARK: Functions
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Toggle LiveRanking UI
 *
 *	@param	_Display								Display the UI or not
 *	@param	_UseAnimation						Use animation
 */
Void ToggleUI(Boolean _Display, Boolean _UseAnimation) {
	declare CMlFrame Frame <=> (Page.GetFirstChild("frame-liveranking") as CMlFrame);
	declare CMlFrame Frame_Content <=> (Frame.GetFirstChild("frame-liveranking-content") as CMlFrame);
	declare CMlQuad Quad_ToggleButton <=> (Frame.GetFirstChild("quad-liveranking-togglebutton") as CMlQuad);

	AnimMgr.Flush(Frame_Content);
	AnimMgr.Flush(Quad_ToggleButton);

	if (_Display) {
		Quad_ToggleButton.ImageUrl = Icons::C_Icon_128x128_Arrow_Left_Oblique;
		Frame_Content.Visible = True;

		if (_UseAnimation) {
			AnimMgr.Add(Quad_ToggleButton, "<a pos=\"0 "^Quad_ToggleButton.RelativePosition_V3.Y^ "\"/>", Now, 250, CAnimManager::EAnimManagerEasing::Linear);
			AnimMgr.Add(Frame_Content, "<a pos=\"0 "^Frame_Content.RelativePosition_V3.Y^ "\" />", Now, 250, CAnimManager::EAnimManagerEasing::Linear);
		} else {
			Quad_ToggleButton.RelativePosition_V3.X = 0.;
			Frame_Content.RelativePosition_V3.X = 0.;
		}
	} else {
		Quad_ToggleButton.ImageUrl = Icons::C_Icon_128x128_Arrow_Right_Oblique;
		if (_UseAnimation) {
			AnimMgr.Add(Quad_ToggleButton, "<a pos=\"-55 "^ Quad_ToggleButton.RelativePosition_V3.Y ^"\"/>", Now, 250, CAnimManager::EAnimManagerEasing::Linear);
			AnimMgr.Add(Frame_Content, "<a pos=\"-55 "^ Frame_Content.RelativePosition_V3.Y ^"\" hidden=\"1\"/>", Now, 250, CAnimManager::EAnimManagerEasing::Linear);
		} else {
			Quad_ToggleButton.RelativePosition_V3.X = -55.;
			Frame_Content.RelativePosition_V3.X = -55.;
			Frame_Content.Visible = False;
		}
	}
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// Update Match info
Void UpdateMatchInfo() {
	declare CMlFrame Frame <=> (Page.GetFirstChild("frame-matchinfo") as CMlFrame);

	declare netread Text Net_MultiLivesKnockout_LiveRanking_MatchName for Teams[0];
	Frame.Visible = (Net_MultiLivesKnockout_LiveRanking_MatchName != "");

	declare CMlLabel Label_Name <=> (Frame.GetFirstChild("label-matchinfo-name") as CMlLabel);
	declare CMlLabel Label_Info <=> (Frame.GetFirstChild("label-matchinfo-info") as CMlLabel);

	declare netread Boolean Net_MultiLivesKnockout_AlternativePosition for Teams[0];
	if (Net_MultiLivesKnockout_AlternativePosition) Frame.RelativePosition_V3.Y = 50.;
	else Frame.RelativePosition_V3.Y = 80.;

	Label_Name.Value = Net_MultiLivesKnockout_LiveRanking_MatchName;
	Tools::FitLabelValue(Label_Name, 3.5, 2., .2);

	declare netread Text Net_MultiLivesKnockout_LiveRanking_MatchInfo for Teams[0];
	Label_Info.Value = Net_MultiLivesKnockout_LiveRanking_MatchInfo;
	Tools::FitLabelValue(Label_Info, 1.3, .4, .1);
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Transform delta time to pretty value
 *
 *	@param	_Time													Display the UI or not
 *	@return 															Human readable delta time
 */
Text TimeToText(Integer _Time) {		
	if (_Time < 1000) {
		return TL::FormatReal(_Time / 1000., 3, False, False);
	}

	declare TimeWithoutMs = _Time / 10;
	declare TimeInSeconds = TimeWithoutMs / 100.;
	if (TimeInSeconds <= 10.) {
		return TL::FormatReal(TimeInSeconds, 2, False, False);
	} else if (TimeInSeconds <= 100.) {
		return TL::FormatReal(TimeInSeconds, 1, False, False);
	}
	return TL::ToText(ML::FloorInteger(TimeInSeconds));
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Display official Knockout Warning
 *
 *	@param	_Display													Display
 */
Void DisplayWarning(Boolean _Display) {		
	EliminationStatus::SetOwnerEliminated(UI, _Display);
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Transform delta time to pretty value
 *
 *	@param	_Control_Player							CMlControl of the Player Line
 *	@param	_PlayerState								Player State
 */
Void UpdateRankingPlayer(CMlControl _Control_Player, K_PlayerState _PlayerState) {
	declare CMlFrame Frame_Player <=> (_Control_Player as CMlFrame);
	if (Frame_Player == Null) return;
	if (!Frame_Player.Visible) Frame_Player.Visible = True;

	declare netread Integer Net_MultiLivesKnockout_LiveRanking_MaximumLives for Teams[0];

	// Set Rank
	declare CMlLabel Label_Player_Rank <=> (Frame_Player.GetFirstChild("label-player-rank") as CMlLabel);
	Label_Player_Rank.Value = TL::ToText(_PlayerState.Rank);

	// Set Name
	declare CMlLabel Label_Player_Name <=> (Frame_Player.GetFirstChild("label-player-name") as CMlLabel);
	Label_Player_Name.Value = _PlayerState.Name;
	Tools::FitLabelValue(Label_Player_Name, 1.5, .8, .1);

	// Set Points
	declare CMlLabel Label_Player_Lives <=> (Frame_Player.GetFirstChild("label-player-lives") as CMlLabel);
	switch (_PlayerState.Lives) {
		case 3: Label_Player_Lives.Value = "";
		case 2: Label_Player_Lives.Value = "";
		case 1: Label_Player_Lives.Value = "";
		default: Label_Player_Lives.Value = ""; // If Lives = 0, it's because MaximumLives > 3
	}

	// Set Spectate Button
	declare CMlQuad Quad_Player_Button <=> (Frame_Player.GetFirstChild("quad-player-button") as CMlQuad);
	declare Text Quad_Login for Quad_Player_Button = "";
	if (_PlayerState.IsNotPlaying) Quad_Login = "";
	else Quad_Login = _PlayerState.Login;
	
	// Set CP Time Background
	declare CMlQuad Quad_Player_Time_Background <=> (Frame_Player.GetFirstChild("quad-player-time-background") as CMlQuad);
	if (WarmupHelpers::IsWarmupActive(Teams[0])) Quad_Player_Time_Background.BgColor = <0.96, 0.35, 0.14>;
	else if (_PlayerState.InDanger) Quad_Player_Time_Background.BgColor = <1., 0., 0.>;
	else Quad_Player_Time_Background.BgColor = <1., 1., 1.>;

	//Set background opacity (if playing or spectated)
	declare CMlQuad Quad_Player_Bg <=> (Frame_Player.GetFirstChild("quad-player-selector") as CMlQuad);
	if (GUIPlayer != Null && GUIPlayer.Score.Id == _PlayerState.ScoreId) {
		Quad_Player_Bg.Opacity = 0.3;
		Quad_Player_Time_Background.Opacity = 0.3;
		DisplayWarning(_PlayerState.InDanger);
	} else {
		Quad_Player_Bg.Opacity = 0.;
		Quad_Player_Time_Background.Opacity = 0.2;
	}

	// Set CP Time
	declare CMlLabel Label_Player_CP_Time <=> (Frame_Player.GetFirstChild("label-player-time") as CMlLabel);
	if (WarmupHelpers::IsWarmupActive(Teams[0])) Label_Player_CP_Time.Value = "-";
	else if (_PlayerState.IsNotPlaying && !_PlayerState.Finished) Label_Player_CP_Time.Value = "DNF";
	else if (_PlayerState.Rank == 1) Label_Player_CP_Time.Value = TL::TimeToText(_PlayerState.LastCPTime, True, True);
	else if (_PlayerState.LastCPTime == 0) Label_Player_CP_Time.Value = "-";
	else Label_Player_CP_Time.Value = "+" ^ TimeToText(_PlayerState.Delta);
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
// Update Live Ranking UI
Void UpdateRanking() {
	// map Score Id to Player Id
	declare Ident[Ident] ScoreIdToPlayerId;
	foreach (Player in Players) {
			if (Player.Score != Null) {
					ScoreIdToPlayerId[Player.Score.Id] = Player.Id;
			}
	}

	declare K_PlayerState[][Integer][Integer] Ranking; // Ranking[<CP number>][<Time>][<Players>]
	declare netread Integer Net_MultiLivesKnockout_LiveRanking_MaximumLives for Teams[0];
	declare Integer PlayersNb = 0;
	declare Integer GlobalLastCPTime = -1;

	// Build Ranking array
	foreach (Score in Scores) {
		if (Score.User == Null) continue;

		declare netread Boolean Net_MultiLivesKnockout_IsRegistered for Score;
		if (!Net_MultiLivesKnockout_IsRegistered) continue;

		declare netread Integer Net_MultiLivesKnockout_ConsumedLives for Score;
		declare Integer Lives = Net_MultiLivesKnockout_LiveRanking_MaximumLives - Net_MultiLivesKnockout_ConsumedLives;
		if (Lives <= 0) continue; // Skip KO player
		if (Net_MultiLivesKnockout_LiveRanking_MaximumLives > 3) Lives = 0; // Display hearts only if max live <= 3

		declare K_PlayerState PlayerState = K_PlayerState {
			Name = Score.User.Name,
			Login = Score.User.Login,
			ScoreId = Score.Id,
			Lives = Lives,
			IsNotPlaying = True
		};

		if (WarmupHelpers::IsWarmupActive(Teams[0])) {
			PlayerState.IsNotPlaying = False;
		} else {
			declare Ident PlayerId = ScoreIdToPlayerId.get(Score.Id, NullId);
			if (PlayerId != NullId) {
				declare CSmPlayer Player <=> Players.get(PlayerId, Null);
				if (Player != Null) {
					PlayerState.CPNb = Player.RaceWaypointTimes.count;
					PlayerState.IsNotPlaying = (Player.SpawnStatus == CSmPlayer::ESpawnStatus::NotSpawned);
					PlayerState.Finished = (Score.PrevRaceTimes.count != 0);
		
					if (PlayerState.CPNb > 0) {
						PlayerState.LastCPTime = Player.RaceWaypointTimes[-1];
					}
					if (GlobalLastCPTime < PlayerState.LastCPTime) GlobalLastCPTime = PlayerState.LastCPTime;
				}
			}
		}

		if (!Ranking.existskey(PlayerState.CPNb)) Ranking[PlayerState.CPNb] = [];
		if (!Ranking[PlayerState.CPNb].existskey(PlayerState.LastCPTime)) Ranking[PlayerState.CPNb][PlayerState.LastCPTime] = [];

		Ranking[PlayerState.CPNb][PlayerState.LastCPTime].add(PlayerState);

		PlayersNb += 1;
	}

	// Sort Ranking by CP Count
	Ranking = Ranking.sortkeyreverse();

	// Players variables
	declare Integer Rank = 1;
	declare CSmPlayer FirstPlayer;
	declare Integer MinDelta = 0;

	declare netread Integer Net_MultiLivesKnockout_LiveRanking_LossOfLife for Teams[0];
	declare Integer LostOfLifeRank = PlayersNb - Net_MultiLivesKnockout_LiveRanking_LossOfLife + 1;

	// Display only variables
	declare Integer FrameIndex = 0;
	declare CMlFrame Frame_Players <=> (Page.GetFirstChild("frame-liveranking-players") as CMlFrame);

	declare Integer DisplayLinesNb = ML::Min(Frame_Players.Controls.count, PlayersNb);

	declare Integer RemainingTopLines = C_LinesNb_Top;
	declare Integer MaxDangerLines = DisplayLinesNb - RemainingTopLines;

	declare Integer MiddleLinesNb = ML::Max(DisplayLinesNb - RemainingTopLines - Net_MultiLivesKnockout_LiveRanking_LossOfLife, 3);
	declare Integer RemainingMiddleLines = MiddleLinesNb;
	
	declare Boolean GUIPlayerIsPassed = (GUIPlayer == Null); // We consider GUIPlayer passed if Null

	declare K_PlayerState[] PreviousPlayerStates;


	foreach (CPNb => CPTimes in Ranking) {
		// Sort Times for this CP
		declare K_PlayerState[][Integer] SortedCPTimes = CPTimes.sortkey();

		foreach (CPTime => PlayerStates in SortedCPTimes) {
			foreach (Key => PlayerStateRO in PlayerStates) { // If multiple players have the same time
				// Variable Dummy = PlayerState but is Read-Only. So I redefine it here:
				declare K_PlayerState PlayerState = PlayerStateRO;

				PlayerState.Rank = Rank;
				PlayerState.InDanger = (Rank >= LostOfLifeRank);

				if (FirstPlayer == Null) {
					declare Ident FirstPlayerId = ScoreIdToPlayerId.get(PlayerState.ScoreId, NullId);
					if (FirstPlayerId != NullId) {
						FirstPlayer <=> Players[FirstPlayerId];
					}
				}

				if (FirstPlayer != Null) {
					declare Integer Delta = 0;
					if (CPNb > 0) {
						if (FirstPlayer.RaceWaypointTimes.existskey(CPNb)) { // Get Delta Time based on the next CP if needed (if the player is slow during the CP)
							Delta = ML::Max(PlayerState.LastCPTime - FirstPlayer.RaceWaypointTimes[CPNb - 1], GlobalLastCPTime - FirstPlayer.RaceWaypointTimes[CPNb]);
						} else {
							Delta = PlayerState.LastCPTime - FirstPlayer.RaceWaypointTimes[CPNb - 1];
						}
					}

					// Store the Minimal Delta for before the 1st CP
					if (Delta > MinDelta) {
						MinDelta = Delta;
					} else {
						Delta = MinDelta;
					}
					PlayerState.Delta = Delta;
				}

				if (DisplayLinesNb >= PlayersNb) { // Enough lines to display
					UpdateRankingPlayer(Frame_Players.Controls[FrameIndex], PlayerState);
					FrameIndex += 1;
				} else if (RemainingTopLines > 0) { // Display Top
					UpdateRankingPlayer(Frame_Players.Controls[FrameIndex], PlayerState);
					if (!GUIPlayerIsPassed) GUIPlayerIsPassed = (GUIPlayer.Score.Id == PlayerState.ScoreId);
					RemainingTopLines -= 1;
					FrameIndex += 1;
				} else if (GUIPlayerIsPassed && RemainingMiddleLines > 0) { // Display lines after GUIPlayer before the danger zone
					UpdateRankingPlayer(Frame_Players.Controls[FrameIndex], PlayerState);
					RemainingMiddleLines -= 1;
					FrameIndex += 1;
				} else if (GUIPlayerIsPassed && Rank >= LostOfLifeRank) { // In danger zone
					UpdateRankingPlayer(Frame_Players.Controls[FrameIndex], PlayerState);
					FrameIndex += 1;
				} else if (!GUIPlayerIsPassed && GUIPlayer.Score.Id == PlayerState.ScoreId) { // Display Previous Players + GUIPlayer in Middle lines			
					// The slicing method is a very complex thing, do not touch if you don't want to break everything
					declare Integer MinLinesBefore = ML::NearestInteger((MiddleLinesNb - 1) / 2.); // Ceiling return 2 for 1.0 in Maniascript. So using NearestInteger
					declare Integer MaxLinesAfter = MaxDangerLines - MinLinesBefore - 1;
					declare Integer RemainingPlayers = PlayersNb - Rank;

					declare Integer Slice = ML::Max(PreviousPlayerStates.count - MinLinesBefore - ML::Max(MaxLinesAfter - RemainingPlayers, 0), 0);

					PreviousPlayerStates = PreviousPlayerStates.slice(Slice);

					// Display previous PlayerStates
					while (PreviousPlayerStates.count > 0) {
						UpdateRankingPlayer(Frame_Players.Controls[FrameIndex], PreviousPlayerStates[0]);
						PreviousPlayerStates = PreviousPlayerStates.slice(1);
						FrameIndex += 1;
						RemainingMiddleLines -= 1;
					}
					// display current PlayerState
					UpdateRankingPlayer(Frame_Players.Controls[FrameIndex], PlayerState);

					GUIPlayerIsPassed = True;
					FrameIndex += 1;
					RemainingMiddleLines -= 1;
				} else { // Store Previous PlayerStates
					PreviousPlayerStates.add(PlayerState);
					if (PreviousPlayerStates.count > MaxDangerLines) {
						PreviousPlayerStates = PreviousPlayerStates.slice(1);
					}
				}

				Rank += 1;
				if (!Frame_Players.Controls.existskey(FrameIndex)) break;
			}
			if (!Frame_Players.Controls.existskey(FrameIndex)) break;
		}
		if (!Frame_Players.Controls.existskey(FrameIndex)) break;
	}

	// Manage if Nb Of players changed
	declare Integer Last_NbOfFrames for Frame_Players = 0;
	if (Last_NbOfFrames != DisplayLinesNb) {
		Last_NbOfFrames = DisplayLinesNb;

		// Set 
		declare CMlQuad Quad_Bg <=> (Page.GetFirstChild("quad-liveranking-background") as CMlQuad);
		Quad_Bg.Size.Y = ML::ToReal(12 + (Last_NbOfFrames * 5));

		// Hide other Frame_Players
		while (FrameIndex < Frame_Players.Controls.count) {
			if (Frame_Players.Controls[FrameIndex].Visible) {
				Frame_Players.Controls[FrameIndex].Visible = False;
				FrameIndex += 1;
			} else {
				break;
			}
		}
	}
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
/** Spectate player using their login
 *
 *	@param	_Login									Login of the Player
 */
Void SpectateLogin(Text _Login) {
	ClientUI.Spectator_SetForcedTarget_Clear();
	SetSpectateTarget(_Login);
}

main() {
	log("Init "^ ScriptName ^" v"^ Version);
	declare CMlFrame Frame_Global <=> (Page.GetFirstChild("frame-global") as CMlFrame);
	declare CMlFrame Frame_LiveRanking <=> (Page.GetFirstChild("frame-liveranking") as CMlFrame);

	wait (InputPlayer != Null);
	Frame_Global.Visible = True;

	declare netread Boolean Net_MultiLivesKnockout_LiveRanking_Display for Teams[0] = False;

	declare persistent Boolean MultiLivesKnockout_LiveRanking_IsVisible for InputPlayer.User = True;
	ToggleUI(MultiLivesKnockout_LiveRanking_IsVisible, False);

	declare netread Integer Net_MultiLivesKnockout_LiveRanking_Info_Serial for Teams[0];
	declare Integer Last_Info_Serial;

	declare netread Integer Net_MultiLivesKnockout_LiveRanking_Serial for Teams[0];
	declare Integer Last_LiveRanking_Serial;

	declare Ident Last_GUIPlayer;

	declare Boolean UpdateLiveRanking = True;

	while (True) {
		yield;
		if (!PageIsVisible) continue;

		if (Last_Info_Serial != Net_MultiLivesKnockout_LiveRanking_Info_Serial) {
			Last_Info_Serial = Net_MultiLivesKnockout_LiveRanking_Info_Serial;
			UpdateMatchInfo();
		}

		Frame_LiveRanking.Visible = Net_MultiLivesKnockout_LiveRanking_Display;
		if (!Frame_LiveRanking.Visible) {
			DisplayWarning(False);
			continue;
		}

		if (Last_LiveRanking_Serial != Net_MultiLivesKnockout_LiveRanking_Serial) {
			Last_LiveRanking_Serial = Net_MultiLivesKnockout_LiveRanking_Serial;
			UpdateLiveRanking = True;
		}

		foreach (Event in PendingEvents) {
			switch (Event.Type) {
				case CMlScriptEvent::Type::MouseClick: {
					switch (Event.ControlId) {
						case "quad-player-button": {
							if (InputPlayer == GUIPlayer) continue;
							declare Text Quad_Login for Event.Control = "";
							SpectateLogin(Quad_Login);
						}
						case "quad-liveranking-togglebutton": {
							MultiLivesKnockout_LiveRanking_IsVisible = !MultiLivesKnockout_LiveRanking_IsVisible;
							ToggleUI(MultiLivesKnockout_LiveRanking_IsVisible, True);
						}
					}
				}
				case CMlScriptEvent::Type::MouseOver: {
					switch (Event.ControlId) {
						case "quad-player-button": {
							if (InputPlayer == GUIPlayer) continue;
							declare CMlQuad Quad <=> (Event.Control.Parent.GetFirstChild("quad-player-selector") as CMlQuad);
							if (Quad.Opacity < .25) {
								Quad.Opacity = .2;
							}
						}
					}
				}
				case CMlScriptEvent::Type::MouseOut: {
					switch (Event.ControlId) {
						case "quad-player-button": {
							declare CMlQuad Quad <=> (Event.Control.Parent.GetFirstChild("quad-player-selector") as CMlQuad);
							if (Quad.Opacity < .25) {
								Quad.Opacity = 0.;
							}
						}
					}
				}
			}
		}

		if (GUIPlayer == Null && Last_GUIPlayer != NullId) {
			Last_GUIPlayer == NullId;
			UpdateLiveRanking = True;
		} else if (GUIPlayer != Null && Last_GUIPlayer != GUIPlayer.Id) {
			Last_GUIPlayer = GUIPlayer.Id;
			UpdateLiveRanking = True;
		}

		// Need to be update even when hidden to trigger Knockout Warning
		if (UpdateLiveRanking) { 
			UpdateLiveRanking = False;
			UpdateRanking();
		}
	}
}
--></script>
</manialink>
""";
	Layers::Create(C_MlId_LiveRanking, MLText);
	Layers::SetType(C_MlId_LiveRanking, CUILayer::EUILayerType::Normal);
	Layers::Attach(C_MlId_LiveRanking);
}