From fb326d725b89bfbe943a476dbcf83eb3a08852f1 Mon Sep 17 00:00:00 2001 From: Beu Date: Mon, 4 Sep 2023 18:09:21 +0200 Subject: [PATCH] Add Rounds Nearest script --- TM_RoundsNearest.Script.txt | 556 ++++++++++++++++++++++++++++++++++++ 1 file changed, 556 insertions(+) create mode 100644 TM_RoundsNearest.Script.txt diff --git a/TM_RoundsNearest.Script.txt b/TM_RoundsNearest.Script.txt new file mode 100644 index 0000000..6cc7560 --- /dev/null +++ b/TM_RoundsNearest.Script.txt @@ -0,0 +1,556 @@ +/** + * Rounds mode + */ +#Extends "Libs/Nadeo/TMNext/TrackMania/Modes/TMNextRoundsBase.Script.txt" + +#Const CompatibleMapTypes "TrackMania\\TM_Race,TM_Race" +#Const Version "2023-09-04" +#Const ScriptName "Modes/TM2020-Gamemodes/TM_RoundsNearest.Script.txt" + +// #RequireContext CSmMode + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +// Libraries +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +#Include "TextLib" as TL +#Include "MathLib" as ML +#Include "Libs/Nadeo/CommonLibs/Common/Semver.Script.txt" as Semver +#Include "Libs/Nadeo/TMNext/TrackMania/Menu/Constants.Script.txt" as MenuConsts +#Include "Libs/Nadeo/TMNext/TrackMania/Modes/Rounds/StateManager.Script.txt" as StateMgr +#Include "Libs/Nadeo/CommonLibs/Common/Tracking.Script.txt" as Tracking +#Include "ManiaApps/Nadeo/TMxSM/Race/UIModules/Checkpoint_Server.Script.txt" as UIModules_Checkpoint +#Include "ManiaApps/Nadeo/TMxSM/Race/UIModules/PauseMenuOnline_Server.Script.txt" as UIModules_PauseMenu_Online + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +// Settings +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +#Setting S_PointsLimit 20 as _("Points limit") +#Setting S_FinishTimeout -1 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_MapsPerMatch -1 as _("Number of tracks per match") ///< Number of maps to play before finishing the match +#Setting S_UseTieBreak True as _("Use tie-break") ///< Continue to play the map until the tie is broken +#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_PointsRepartition "1,0" +#Setting S_BonusForPerfect 4 +#Setting S_TargetTime 20000 + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +// Constants +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +#Const C_ModeName "Rounds" +//L16N [Rounds] Description of the mode rules +#Const Description _("$zIn $<$t$6F9Rounds$z$z$> mode, the goal is to win a maximum number of $<$t$6F9points.\n\n$z$>The rounds mode consists of $<$t$6F9a series of races$z$>.\nWhen you finish a race in a good $<$t$6F9position$z$>, you get $<$t$6F9points$z$>, added to your total.\n\nThe $<$t$6F9winner$z$> is the first player whose total reaches the $<$t$6F9point limit$z$> (30 for example).") + +#Const C_HudModulePath "" //< Path to the hud module +#Const C_ManiaAppUrl "file://Media/ManiaApps/Nadeo/TMNext/TrackMania/Rounds/Rounds.Script.txt" //< Url of the mania app + +#Const C_PointsLimit_NotReached 0 +#Const C_PointsLimit_Reached 1 +#Const C_PointsLimit_Tie 2 + +#Const C_UploadRecord True +#Const C_DisplayRecordGhost False +#Const C_DisplayRecordMedal False +#Const C_CelebrateRecordGhost True +#Const C_CelebrateRecordMedal True + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +// 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*** +*** +StateMgr::Load(); +*** + +***Match_UnloadLibraries*** +*** +StateMgr::Unload(); +*** + +***Match_Settings*** +*** +MB_Settings_UseDefaultHud = (C_HudModulePath == ""); +*** + +***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_ScoresTable::SetScoreMode(UIModules_ScoresTable::C_Mode_Points); +UIModules_Checkpoint::SetVisibilityTimeDiff(False); +UIModules_Checkpoint::SetRankMode(UIModules_Checkpoint::C_RankMode_CurrentRace); +UIModules_PauseMenu_Online::SetHelp(Description); +UIModules_Sign16x9Small::SetScoreMode(UIModules_Sign16x9Small::C_ScoreMode_Points); +// Hide SM Overlay +UIManager.UIAll.OverlayHideSpectatorControllers = True; +UIManager.UIAll.OverlayHideSpectatorInfos = True; +UIManager.UIAll.OverlayHideChrono = True; +UIManager.UIAll.OverlayHideCountdown = True; + +UIModules_ScoresTable::DisplayRoundPoints(True); +UIModules::UnloadModules(["UIModule_Race_TimeGap", "UIModule_Rounds_SmallScoresTable"]); +*** + +***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); + } + } +} + +StateMgr::Yield(); +*** + +***Match_InitServer*** +*** +declare Integer Server_PointsLimit; +declare Integer Server_RoundsPerMap; +declare Integer Server_MapsPerMatch; +*** + +***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_Rounds, + "", + C_UploadRecord, + C_DisplayRecordGhost, + C_DisplayRecordMedal, + C_CelebrateRecordGhost, + C_CelebrateRecordMedal +); + +Server_PointsLimit = S_PointsLimit - 1; +Server_RoundsPerMap = S_RoundsPerMap - 1; +Server_MapsPerMatch = S_MapsPerMatch - 1; +*** + +***Match_InitMap*** +*** +declare Integer Map_ValidRoundsNb; +declare Boolean Map_Skipped; + +UpdateScoresTableFooter(S_PointsLimit, S_RoundsPerMap, S_MapsPerMatch, Map_ValidRoundsNb); +*** + +***Match_StartMap*** +*** +Map_Skipped = True; +CarRank::Reset(); +UIModules_ScoresTable::SetCustomPoints([]); + +// Warm up +UIModules_ScoresTable::SetFooterInfo(_("Warm up")); +MB_WarmUp(S_WarmUpNb, S_WarmUpDuration * 1000, S_WarmUpTimeout * 1000); +*** + +***Match_StartRound*** +*** +UpdateScoresTableFooter(S_PointsLimit, S_RoundsPerMap, S_MapsPerMatch, Map_ValidRoundsNb); +StateMgr::ForcePlayersStates([StateMgr::C_State_Playing]); +UIModules_ScoresTable::SetCustomPoints([]); +*** + +***Rounds_PlayerSpawned*** +*** +CarRank::ThrottleUpdate(CarRank::C_SortCriteria_CurrentRace); +*** + +***Match_PlayLoop*** +*** +// Manage race events +declare Events::K_RaceEvent[] RacePendingEvents = Race::GetPendingEvents(); +foreach (Event in RacePendingEvents) { + Race::ValidEvent(Event); + + // Waypoint + if (Event.Type == Events::C_Type_Waypoint) { + CarRank::ThrottleUpdate(CarRank::C_SortCriteria_CurrentRace); + if (Event.Player != Null) { + if (Event.IsEndRace) { + Scores::UpdatePlayerBestRaceIfBetter(Event.Player); + Scores::UpdatePlayerBestLapIfBetter(Event.Player); + Scores::UpdatePlayerPrevRace(Event.Player); + ComputeLatestRaceScores(); + Race::SortScores(Race::C_Sort_TotalPoints); + + // Start the countdown if it's the first player to finish + if (EndTime <= 0) { + EndTime = GetFinishTimeout(S_FinishTimeout); + } + } + if (Event.IsEndLap) { + Scores::UpdatePlayerBestLapIfBetter(Event.Player); + } + } + } +} + +// Manage mode events +foreach (Event in PendingEvents) { + if (Event.HasBeenPassed || Event.HasBeenDiscarded) continue; + Events::Invalid(Event); +} + +// Server info change +if ( + Server_PointsLimit != S_PointsLimit || + Server_RoundsPerMap != S_RoundsPerMap || + Server_MapsPerMatch != S_MapsPerMatch +) { + Server_PointsLimit = S_PointsLimit; + Server_RoundsPerMap = S_RoundsPerMap; + Server_MapsPerMatch = S_MapsPerMatch; + + UpdateScoresTableFooter(S_PointsLimit, S_RoundsPerMap, S_MapsPerMatch, Map_ValidRoundsNb); +} +*** + +***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, ""); +} + +if (Round_ForceEndRound || Round_SkipPauseRound || Round_Skipped) { + // 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(); + } +} else { + Map_ValidRoundsNb += 1; + // Get the last round points + ComputeLatestRaceScores(); + Race::SortScores(Race::C_Sort_TotalPoints); + UIManager.UIAll.ScoreTableVisibility = CUIConfig::EVisibility::ForcedVisible; + UIManager.UIAll.UISequence = CUIConfig::EUISequence::EndRound; + MB_Sleep(3000); + // Add them to the total scores + ComputeScores(); + UIModules_ScoresTable::SetCustomPoints([]); + Race::SortScores(Race::C_Sort_TotalPoints); + MB_Sleep(3000); + UIManager.UIAll.ScoreTableVisibility = CUIConfig::EVisibility::Normal; + UIManager.UIAll.UISequence = CUIConfig::EUISequence::Playing; + + if (MapIsOver(S_UseTieBreak, S_PointsLimit, Map_ValidRoundsNb, S_RoundsPerMap)) { + Map_Skipped = False; + MB_StopMap(); + } +} +*** + +***Match_EndMap*** +*** +if (MatchIsOver(S_UseTieBreak, S_PointsLimit, MB_GetMapCount(), S_MapsPerMatch, S_RoundsPerMap, Map_Skipped)) MB_StopMatch(); + +if (!MB_MapIsRunning() && MB_MatchIsRunning()) MB_SkipPodiumSequence(); + +Race::SortScores(Race::C_Sort_TotalPoints); +declare CSmScore Winner <=> Scores::GetBestPlayer(Scores::C_Sort_MatchPoints); +Scores::SetPlayerWinner(Winner); + +if (!MB_MatchIsRunning()) { + // Compute ranking for tracking + declare Integer PreviousPoints = 0; + declare Integer Rank = 0; + foreach (Key => Score in Scores) { + if (Key == 0 || Scores::GetPlayerMatchPoints(Score) < PreviousPoints) { + PreviousPoints = Scores::GetPlayerMatchPoints(Score); + Rank = Key + 1; + } + Tracking::SendPlayerMatchResult(UIManager, Score.User, Rank, Winner == Score && Scores.count > 1); + } +} +*** + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +// Functions +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +/** Update the scores table footer text + * + * @param _PointsLimit The points limit + * @param _RoundsPerMap The number of rounds per map + * @param _MapsPerMatch The number of maps per match + * @param _ValidRoundsNb Number of valid rounds played + */ +Void UpdateScoresTableFooter(Integer _PointsLimit, Integer _RoundsPerMap, Integer _MapsPerMatch, Integer _ValidRoundsNb) { + declare Text[] Parts; + declare Text Message = ""; + if (_PointsLimit > 0) { + if (Parts.count > 0) Message ^= "\n"; + Message ^= """%{{{Parts.count + 1}}}{{{_PointsLimit}}}"""; + //L16N [Rounds] Number of points to reach to win the match. + Parts.add(_("Points limit : ")); + } + if (_RoundsPerMap > 0) { + if (Parts.count > 0) Message ^= "\n"; + Message ^= """%{{{Parts.count + 1}}}{{{ML::Min(_ValidRoundsNb+1, _RoundsPerMap)}}}/{{{_RoundsPerMap}}}"""; + //L16N [Rounds] Number of rounds played during the track. + Parts.add(_("Rounds : ")); + } + if (_MapsPerMatch > 0) { + if (Parts.count > 0) Message ^= "\n"; + Message ^= """%{{{Parts.count + 1}}}{{{MB_GetMapCount()}}}/{{{_MapsPerMatch}}}"""; + //L16N [Rounds] Number of tracks played during the match. + Parts.add(_("Tracks : ")); + } + + switch (Parts.count) { + case 0: UIModules_ScoresTable::SetFooterInfo(Message); + case 1: UIModules_ScoresTable::SetFooterInfo(TL::Compose(Message, Parts[0])); + case 2: UIModules_ScoresTable::SetFooterInfo(TL::Compose(Message, Parts[0], Parts[1])); + case 3: UIModules_ScoresTable::SetFooterInfo(TL::Compose(Message, Parts[0], Parts[1], Parts[2])); + } +} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +/** Get the time left to the players to finish the round after the first player + * + * @return The time left in ms + */ +Integer GetFinishTimeout(Integer _FinishTimeout) { + declare Integer FinishTimeout = 0; + + if (_FinishTimeout >= 0) { + FinishTimeout = _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; +} + +Text DeltaTimeToText(Integer _Time) { + if (_Time < 1000) { + return TL::FormatReal(_Time / 1000., 3, False, False); + } + + declare Real TimeWithoutMs = _Time / 10.; + declare Real 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)); +} + +Text FormatPlayerName(Text _Name) { + return "$<$fff" ^ _Name ^ "$>"; +} + + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +/// Compute the latest race scores +Void ComputeLatestRaceScores() { + Race::SortScores(Race::C_Sort_PrevRaceTime); + + // Points distributed between all players + + declare Text[][Text] CustomPoints = []; + declare CSmScore[][Integer] ScoresPerAbsoluteDelta; + foreach (Score in Scores) { + if (Score.User == Null) continue; + if (Scores::GetPlayerPrevRaceTime(Score) <= 0) continue; + declare Integer Delta = Scores::GetPlayerPrevRaceTime(Score) - S_TargetTime; + declare Integer AbsoluteDelta = ML::Abs(Delta); + if (!ScoresPerAbsoluteDelta.existskey(AbsoluteDelta)) ScoresPerAbsoluteDelta[AbsoluteDelta] = []; + ScoresPerAbsoluteDelta[AbsoluteDelta].add(Score); + + declare Text TextDelta; + if (Delta >= 0) TextDelta = "+"; + else TextDelta = "-"; + + TextDelta ^= DeltaTimeToText(AbsoluteDelta); + CustomPoints[Score.User.WebServicesUserId] = [Scores::GetPlayerMatchPoints(Score) ^ " (" ^ TextDelta ^ ")"]; + } + UIModules_ScoresTable::SetCustomPoints(CustomPoints); + + ScoresPerAbsoluteDelta = ScoresPerAbsoluteDelta.sortkey(); + + declare Integer I = 0; + declare Integer[] PointsRepartition = PointsRepartition::GetPointsRepartition(); + + foreach (Delta => CustomScores in ScoresPerAbsoluteDelta) { + // Attribute less points if they have the same time + if (CustomScores.count > 1) { + I += CustomScores.count - 1; + declare Text Names; + foreach (Key => Score in CustomScores) { + if (Key == 0) { + Names = FormatPlayerName(Score.User.Name); + } else if (Key == CustomScores.count - 1) { + Names ^= " and " ^ FormatPlayerName(Score.User.Name); + } else { + Names ^= ", " ^ FormatPlayerName(Score.User.Name); + } + } + UIManager.UIAll.SendChat("$ff3" ^ Names^ " have the same time"); + } + foreach (Score in CustomScores) { + declare Integer Points; + + if (PointsRepartition.existskey(I)) { + Points = PointsRepartition[I]; + } else if (PointsRepartition.count > 0) { + Points = PointsRepartition[PointsRepartition.count - 1]; + } + + if (Delta == 0 && CustomScores.count == 1) { + Points += S_BonusForPerfect; + UIManager.UIAll.SendChat("$ff3" ^ FormatPlayerName(Score.User.Name) ^ " did the perfect time"); + } + Scores::SetPlayerRoundPoints(Score, Points); + } + + I += 1; + } +} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +/// Compute the map scores +Void ComputeScores() { + Scores::EndRound(); +} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +/** Check if the points limit was reached + * + * @param _UseTieBreak Prevent ties or not + * @param _PointsLimit Number of points to get to win the match + * + * @return C_PointsLimit_Reached if the points limit is reached + * C_PointsLimit_Tie if there is a tie + * C_PointsLimit_NotReached if the points limit is not reached + */ +Integer PointsLimitReached(Boolean _UseTieBreak, Integer _PointsLimit) { + declare Integer MaxScore = -1; + declare Boolean Tie = False; + foreach (Score in Scores) { + declare Integer Points = Scores::GetPlayerMatchPoints(Score); + if (Points > MaxScore) { + MaxScore = Points; + Tie = False; + } else if (Points == MaxScore) { + Tie = True; + } + } + + if (_UseTieBreak && Tie) return C_PointsLimit_Tie; //< There is a tie and it is not allowed + if (_PointsLimit > 0 && MaxScore >= _PointsLimit) return C_PointsLimit_Reached; //< There is a points limit and it is reached + return C_PointsLimit_NotReached; //< There is no points limit or the points limit is not reached +} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +/** Check if we should go to the next map + * + * @param _UseTieBreak Prevent ties or not + * @param _PointsLimit Number of points to get to win the match + * @param _ValidRoundsNb Number of valid rounds played + * @param _RoundsPerMap Number of rounds to play to complete the map + * + * @return True if it is the case, false otherwise + */ +Boolean MapIsOver(Boolean _UseTieBreak, Integer _PointsLimit, Integer _ValidRoundsNb, Integer _RoundsPerMap) { + declare Integer PointsLimitReached = PointsLimitReached(_UseTieBreak, _PointsLimit); + + Log::Log("""[Rounds] MapIsOver() > _UseTieBreak: {{{_UseTieBreak}}} | _PointsLimit: {{{_PointsLimit}}} | _ValidRoundsNb: {{{_ValidRoundsNb}}} | _RoundsPerMap: {{{_RoundsPerMap}}} | PointsLimitReached: {{{PointsLimitReached}}}"""); + + if (PointsLimitReached == C_PointsLimit_Reached) return True; //< There is a points limit and it is reached + if (_RoundsPerMap > 0 && _ValidRoundsNb >= _RoundsPerMap) return True; //< There is a rounds limit and it is reached + + return False; +} + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // +/** Check if we should go to the next match + * + * @param _UseTieBreak Prevent ties or not + * @param _PointsLimit Number of points to get to win the match + * @param _MapsPerMatch Number of maps to play to complete a match + * @param _RoundsPerMap Number of rounds to play to complete the map + * + * @return True if it is the case, false otherwise + */ +Boolean MatchIsOver(Boolean _UseTieBreak, Integer _PointsLimit, Integer _MapCount, Integer _MapsPerMatch, Integer _RoundsPerMap, Boolean _MapSkipped) { + declare Integer PointsLimitReached = PointsLimitReached(_UseTieBreak, _PointsLimit); + + Log::Log("""[Rounds] MatchIsOver() > _UseTieBreak: {{{_UseTieBreak}}} | _PointsLimit: {{{_PointsLimit}}} | _MapCount: {{{_MapCount}}} | _MapsPerMatch: {{{_MapsPerMatch}}} | _RoundsPerMap: {{{_RoundsPerMap}}} | PointsLimitReached: {{{PointsLimitReached}}} | _MapSkipped : {{{_MapSkipped}}}"""); + + // If there is a point limit and it is reached, stop the match + if (PointsLimitReached == C_PointsLimit_Reached) { + return True; + } + // If there is an explicit maps limit ... + else if (_MapsPerMatch >= 1) { + if ( + (_MapCount >= _MapsPerMatch && PointsLimitReached != C_PointsLimit_Tie) || //< ... stop the match if the maps limit is reached and the match is not a tie + (_MapSkipped && _MapsPerMatch == 1 && _MapCount >= _MapsPerMatch) //< ... stop the match if the map was skipped and the match is played on only one map + ) { + return True; + } + } + // If there is a rounds limit but no maps limit, continue to play until another limit is reached + else if (_RoundsPerMap >= 1) { + return False; + } + // If there is neither a points limit nor a rounds limit, always stop the match at the end of the first map, even if there is a tie + else { + return True; + } + + // In all other cases continue to play + return False; +} +