Fix deprecated code

Scripts/Libs/smokegun/CPTimes.Script.txt

@@ -237,7 +237,7 @@ Void UpdateLayer(CSmPlayer _Player) {
 
  // Make sure times are sorted to get the right cp order
  // But they should be automatically sorted in theory
- LastCPTimes.sort();
+ LastCPTimes = LastCPTimes.sort();
 
  declare nth_cp = 0;
 
@@ -255,8 +255,8 @@ Void UpdateLayer(CSmPlayer _Player) {
  // Remove previous time if it exists
  if (Net_CPTimes_RecordsName[Idx].exists(_Player.User.Name)) {
  declare prev = Net_CPTimes_RecordsName[Idx].keyof(_Player.User.Name);
- Net_CPTimes_RecordsName[Idx].removekey(prev);
- Net_CPTimes_RecordsTime[Idx].removekey(prev);
+ declare Removed = Net_CPTimes_RecordsName[Idx].removekey(prev);
+ Removed = Net_CPTimes_RecordsTime[Idx].removekey(prev);
  }
 
  // Find player rank
@@ -308,10 +308,10 @@ Void StartMap(Integer _CheckpointsNb) {
  Net_CPTimes_RecordsTime.clear();
 
  for (i, 0, _CheckpointsNb) {
- Net_CPTimes_RecordsName.add(Text[]);
- Net_CPTimes_RecordsTime.add(Integer[]);
+ Net_CPTimes_RecordsName.add([]);
+ Net_CPTimes_RecordsTime.add([]);
  }
 
  declare netwrite Integer Net_CPTimesUpdated for Teams[0] = 0;
  Net_CPTimesUpdated = Now;
-}
+}

Scripts/Libs/smokegun/ObstacleLib.Script.txt

@@ -214,7 +214,7 @@ Void Private_UpdateRanking() {
  return;
  }
 
- declare Finished = Integer[Ident];
+ declare Integer[Ident] Finished = [];
  declare CSmPlayer[] Unfinished = [];
 
  // Split finished and unfinished players
@@ -323,7 +323,7 @@ Void Private_CpRestart(CSmPlayer _Player, Integer _Delay, Ident _LastCheckpoint,
 
  // Respawn player
  if (_Player.SpawnStatus == CSmPlayer::ESpawnStatus::Spawned && CanFastRespawn)
- RespawnPlayer(_Player, Checkpoint);
+ RespawnPlayer(_Player, Checkpoint.Waypoint);
  else
  SM::SpawnNoLadder(_Player, 0, Spawn.PlayerSpawn, Now + _Delay);
 
@@ -384,7 +384,7 @@ Void Private_FullRestart(CSmPlayer _Player, Integer _Delay) {
  * Arguments: CSmPlayer _Player Player to respawn
  * Boolean _forceRestart Force spawn to the beginning of the map
  */
-Void RespawnPlayer(CSmPlayer _Player, Boolean _forceRestart) {
+Void ObsRespawnPlayer(CSmPlayer _Player, Boolean _forceRestart) {
  if (_Player.RequestsSpectate)
  return;
 
@@ -429,8 +429,8 @@ Void RespawnPlayer(CSmPlayer _Player, Boolean _forceRestart) {
  *
  * Arguments: CSmPlayer _Player Player to respawn
  */
-Void RespawnPlayer(CSmPlayer _Player) {
- RespawnPlayer(_Player, False);
+Void ObsRespawnPlayer(CSmPlayer _Player) {
+ ObsRespawnPlayer(_Player, False);
 }
 
 /////////////////////////////////////////////////////////////////
@@ -529,45 +529,43 @@ Void JumpToCheckpoint(CSmPlayer _Player, Integer _Target) {
 Void Private_HandleFinish(CSmPlayer _Player, Ident _GoalId) {
  declare Goal <=> MapLandmarks[_GoalId];
 
- declare LastCPTimes = Player::getLastCPTimes(_Player);
- declare BestCPTimes = Player::getBestCPTimes(_Player);
  declare BestRun = Player::getBestRun(_Player);
  declare Time = Player::getTime(_Player);
 
- declare LastRun = Player::setLastRun(_Player, Time);
- LastCPTimes = Player::setLastCPTimes(_Player, _GoalId, Time);
+ Player::setLastRun(_Player, Time);
+ Player::setLastCPTimes(_Player, _GoalId, Time);
 
  // Update time diff before updating best run
- TimeDiff::UpdateLayer(_Player, LastRun, BestRun);
+ TimeDiff::UpdateLayer(_Player, Time, BestRun);
 
  // Check if last run is if last run is better
- if (LastRun < BestRun || BestRun < 0) {
- BestRun = Player::setBestRun(_Player, LastRun);
- BestCPTimes = Player::setBestCPTimes(_Player, LastCPTimes);
+ if (Time < BestRun || BestRun < 0) {
+ Player::setBestRun(_Player, Time);
+ Player::setBestCPTimes(_Player, Player::getLastCPTimes(_Player));
 
  CPTimes::UpdateLayer(_Player);
  Private_UpdatePlayerRsCounter(_Player);
  }
 
  // Send score
- Private_SendFinishedRun(_Player, LastRun, _GoalId);
+ Private_SendFinishedRun(_Player, Time, _GoalId);
  XmlRpc.SendCallback("Obstacle_OnFinish", Player::ToJSON(_Player));
 
  //Update UI
  declare UI <=> UIManager.GetUI(_Player);
  if (UI != Null) {
- declare Time = TL::TimeToText(LastRun, True);
+ declare TimeStr = TL::TimeToText(Time, True);
  declare Variant = 1;
  declare Color = "$f00";
 
  declare message = "";
- if (BestRun == LastRun) {
+ if (Player::getBestRun(_Player) == Time) {
  Variant = 0;
  Color = "$00f";
  message = _("(New Best Time!)");
  }
 
- UI.SendNotice(TL::Compose("%1: $<%2$> %3", _("|Goal|Finish"), Color^Time, message),
+ UI.SendNotice(TL::Compose("%1: $<%2$> %3", _("|Goal|Finish"), Color^TimeStr, message),
  CUIConfig::ENoticeLevel::PlayerInfo, _Player.User, CUIConfig::EAvatarVariant::Default,
  CUIConfig::EUISound::Finish, Variant);
  }
@@ -680,7 +678,7 @@ Boolean HandleCapture(CSmPlayer _Player) {
 
  declare Time = Player::getTime(_Player);
  if (Time < 0) {
- RespawnPlayer(_Player, True);
+ ObsRespawnPlayer(_Player, True);
  return HasCapturedGoal;
  }
 

Scripts/Libs/smokegun/ObstacleRecords.Script.txt

@@ -175,10 +175,11 @@ Void Loop(Text _BestRecordMsg, Text _WorseRecordMsg) {
  Log::Error("G_ToPost_Url and G_ToPost_Data have different sizes!");
  }
 
+
  SendPost(G_ToPost_Url[0], G_ToPost_Data[0]);
 
- G_ToPost_Url.removekey(0);
- G_ToPost_Data.removekey(0);
+ declare Removed = G_ToPost_Url.removekey(0);
+ Removed = G_ToPost_Data.removekey(0);
  }
 
  /*
@@ -237,7 +238,7 @@ Void Loop(Text _BestRecordMsg, Text _WorseRecordMsg) {
  }
 
  // Destroy requests when they are done
- G_CurrRequest.removekey(reqId);
+ declare Removed = G_CurrRequest.removekey(reqId);
  Http.Destroy(request);
 
  }

Scripts/Libs/smokegun/Player.Script.txt

@@ -28,43 +28,39 @@ Boolean isInitialized(CSmPlayer _Player) {
  return isInitialized;
 }
 
-Boolean setInitialized(CSmPlayer _Player, Boolean _Value) {
+Void setInitialized(CSmPlayer _Player, Boolean _Value) {
  declare Boolean isInitialized for _Player = False;
  isInitialized = _Value;
- return isInitialized;
 }
 
 Integer getStartTime(CSmPlayer _Player) {
  declare netwrite Integer Net_StartTime for _Player;
  return Net_StartTime;
 }
 
-Integer setStartTime(CSmPlayer _Player, Integer _Value) {
+Void setStartTime(CSmPlayer _Player, Integer _Value) {
  declare netwrite Integer Net_StartTime for _Player;
  Net_StartTime = _Value;
- return Net_StartTime;
 }
 
 Integer getCpProgress(CSmPlayer _Player) {
  declare netwrite Integer Net_CpProgress for _Player;
  return Net_CpProgress;
 }
 
-Integer setCpProgress(CSmPlayer _Player, Integer _Value) {
+Void setCpProgress(CSmPlayer _Player, Integer _Value) {
  declare netwrite Integer Net_CpProgress for _Player;
  Net_CpProgress = _Value;
- return Net_CpProgress;
 }
 
 Boolean usedJump(CSmPlayer _Player) {
  declare netwrite Boolean Net_UsedJump for _Player = False;
  return Net_UsedJump;
 }
 
-Boolean setUsedJump(CSmPlayer _Player, Boolean _Value) {
+Void setUsedJump(CSmPlayer _Player, Boolean _Value) {
  declare netwrite Boolean Net_UsedJump for _Player = False;
  Net_UsedJump = _Value;
- return Net_UsedJump;
 }
 
 Ident getLastCheckpoint(CSmPlayer _Player) {
@@ -99,32 +95,29 @@ Void setLastCheckpoint(CSmPlayer _Player, Ident _Value) {
 }
 
 Integer[Text] getBuffTimes(CSmPlayer _Player) {
- declare netwrite ItemBuffTimes for _Player = Integer[Text];
+ declare netwrite Integer[Text] ItemBuffTimes for _Player = [];
  return ItemBuffTimes;
 }
 
-Integer[Text] setBuffTime(CSmPlayer _Player, Text _Key, Integer _Value) {
- declare netwrite ItemBuffTimes for _Player = Integer[Text];
+Void setBuffTime(CSmPlayer _Player, Text _Key, Integer _Value) {
+ declare netwrite Integer[Text] ItemBuffTimes for _Player = [];
  ItemBuffTimes[_Key] = _Value;
- return ItemBuffTimes;
 
 }
 
-Integer[Text] clearBuffTimes(CSmPlayer _Player) {
- declare netwrite ItemBuffTimes for _Player = Integer[Text];
+Void clearBuffTimes(CSmPlayer _Player) {
+ declare netwrite Integer[Text] ItemBuffTimes for _Player = [];
  ItemBuffTimes.clear();
- return ItemBuffTimes;
 }
 
 Integer getBestRun(CSmPlayer _Player) {
  declare Integer BestRun for _Player.Score;
  return BestRun;
 }
 
-Integer setBestRun(CSmPlayer _Player, Integer _Value) {
+Void setBestRun(CSmPlayer _Player, Integer _Value) {
  declare Integer BestRun for _Player.Score;
  BestRun = _Value;
- return BestRun;
 }
 
 Integer getLastRunS(CSmScore _Score) {
@@ -137,44 +130,39 @@ Integer getLastRun(CSmPlayer _Player) {
  return LastRun;
 }
 
-Integer setLastRun(CSmPlayer _Player, Integer _Value) {
+Void setLastRun(CSmPlayer _Player, Integer _Value) {
  declare Integer LastRun for _Player.Score;
  LastRun = _Value;
- return LastRun;
 }
 
 Integer getRespawnCount(CSmPlayer _Player) {
  declare Integer RespawnCount for _Player.Score;
  return RespawnCount;
 }
 
-Integer setRespawnCount(CSmPlayer _Player, Integer _Value) {
+Void setRespawnCount(CSmPlayer _Player, Integer _Value) {
  declare Integer RespawnCount for _Player.Score;
  RespawnCount = _Value;
- return RespawnCount;
 }
 
-Integer incrementRespawnCount(CSmPlayer _Player) {
+Void incrementRespawnCount(CSmPlayer _Player) {
  declare Integer RespawnCount for _Player.Score;
  RespawnCount += 1;
- return RespawnCount;
 }
 
 Integer[Ident] getBestCPTimes(CSmPlayer _Player) {
  declare Integer[Ident] CheckpointsTimeBest for _Player.Score;
  return CheckpointsTimeBest;
 }
 
-Integer[Ident] setBestCPTimes(CSmPlayer _Player, Integer[Ident] _Value) {
+Void setBestCPTimes(CSmPlayer _Player, Integer[Ident] _Value) {
  declare Integer[Ident] CheckpointsTimeBest for _Player.Score;
  CheckpointsTimeBest = _Value;
- return CheckpointsTimeBest;
 }
 
-Integer[Ident] clearBestCPTimes(CSmPlayer _Player) {
+Void clearBestCPTimes(CSmPlayer _Player) {
  declare Integer[Ident] CheckpointsTimeBest for _Player.Score;
  CheckpointsTimeBest.clear();
- return CheckpointsTimeBest;
 }
 
 Integer getBestTime(CSmPlayer _Player, Ident _Ident) {
@@ -189,16 +177,14 @@ Integer[Ident] getLastCPTimes(CSmPlayer _Player) {
  return CheckpointsTimeLast;
 }
 
-Integer[Ident] setLastCPTimes(CSmPlayer _Player, Ident _Key, Integer _Value) {
+Void setLastCPTimes(CSmPlayer _Player, Ident _Key, Integer _Value) {
  declare Integer[Ident] CheckpointsTimeLast for _Player.Score;
  CheckpointsTimeLast[_Key] = _Value;
- return CheckpointsTimeLast;
 }
 
-Integer[Ident] clearLastCPTimes(CSmPlayer _Player) {
+Void clearLastCPTimes(CSmPlayer _Player) {
  declare Integer[Ident] CheckpointsTimeLast for _Player.Score;
  CheckpointsTimeLast.clear();
- return CheckpointsTimeLast;
 }
 
 // Declare player's variable

Scripts/Libs/smokegun/Tools.Script.txt

@@ -120,7 +120,7 @@ Ident Private_GetClosestSpawn(Ident _CheckPointId, Ident[] _SpawnIds) {
 
 Ident GetClosestSpawn(Ident _CheckPointId) {
  declare Checkpoint <=> MapLandmarks[_CheckPointId];
- declare SpawnIds = Ident[];
+ declare Ident[] SpawnIds = [];
 
  foreach (Spawn in MapLandmarks_PlayerSpawn) {
  if (IsCpSpawn(Spawn) && (Checkpoint.Order == 0 || Checkpoint.Order == Spawn.Order))
@@ -143,8 +143,8 @@ Ident GetClosestSpawn(Ident _CheckPointId) {
 Integer GetPlayerRank(CSmPlayer _Player) {
  declare LastCheckpointId for _Player = NullId;
  declare BestRun for _Player.Score = -1;
- declare CheckpointsTimeLast for _Player.Score = Integer[Ident];
- declare Ranking = Integer[Ident];
+ declare Integer[Ident] CheckpointsTimeLast for _Player.Score = [];
+ declare Integer[Ident] Ranking = [];
 
  // Player is finishing a run
  if (CheckpointsTimeLast.count == 0) {
@@ -161,7 +161,7 @@ Integer GetPlayerRank(CSmPlayer _Player) {
 
  // Fill ranking with every player who has best time at last checkpoint
  foreach (Score in Scores) {
- declare CheckpointsTimeBest for Score = Integer[Ident];
+ declare Integer[Ident] CheckpointsTimeBest for Score = [];
  if (!CheckpointsTimeBest.existskey(LastCheckpointId)) continue;
  Ranking[Score.User.Id] = CheckpointsTimeBest[LastCheckpointId];
  }

Scripts/Libs/smokegun/UI/SpectatorCount.Script.txt

@@ -3,7 +3,7 @@
 
 
 Void Yield() {
- declare SpeccedPlayers = Integer[Text];
+ declare Integer[Text] SpeccedPlayers = [];
 
  foreach (Player in Spectators) {
  declare UI <=> UIManager.GetUI(Player);
@@ -24,8 +24,8 @@ Void Yield() {
  if (UI == Null) continue;
 
  declare netwrite Integer Net_NbSpectating for Player = 0;
- if (SpeccedPlayers.existskey(Player.Login)) {
- Net_NbSpectating = SpeccedPlayers[Player.Login];
+ if (SpeccedPlayers.existskey(Player.User.Login)) {
+ Net_NbSpectating = SpeccedPlayers[Player.User.Login];
  } else if (Net_NbSpectating != 0) {
  Net_NbSpectating = 0;
  }