private XElement GetPlayerRecordElement(DedimaniaRanking rankingInfo, double currentY, uint currentRank, string login)
{
string templateXML = Settings.RecordListRecordTemplate;
if (rankingInfo.Login == login)
{
templateXML = Settings.RecordListRecordHighlightTemplate;
}
else if (currentRank <= 3)
{
templateXML = Settings.RecordListTop3RecordTemplate;
}
TimeSpan time = TimeSpan.FromMilliseconds(rankingInfo.TimeOrScore);
StringBuilder playerRecordXml = new StringBuilder(templateXML);
playerRecordXml.Replace("{[Y]}", currentY.ToString(CultureInfo.InvariantCulture));
playerRecordXml.Replace("{[Rank]}", currentRank + ".");
playerRecordXml.Replace("{[TimeOrScore]}", rankingInfo.TimeOrScore == 0 ? " --.-- " : string.Format("{0}:{1}.{2}", time.Minutes, time.Seconds.ToString("00"), (time.Milliseconds / 10).ToString("00")));
string nickname = SecurityElement.Escape(rankingInfo.Nickname);
if (Settings.StripNickFormatting)
{
nickname = StripTMColorsAndFormatting(nickname);
}
playerRecordXml.Replace("{[Nickname]}", nickname);
return(XElement.Parse(playerRecordXml.ToString()));
}
protected override void Init()
{
Rankings = new DedimaniaRanking[] {};
Settings = DedimaniaSettings.ReadFromFile(PluginSettingsFilePath);
InitializeDedimaniaClient();
AuthResult authResult = TryAuthentication();
if (authResult == AuthResult.Failed)
{
return;
}
IsDedimaniaResponsive = (authResult == AuthResult.Success);
InitializePlugins();
ResetUpdateServerPlayersTimer();
DedimaniaClient.Url = Settings.ReportUrl;
if (IsDedimaniaResponsive)
{
ReportCurrentChallenge(GetExistingCurrentRankings(), GetCurrentChallengeInfoCached());
}
else
{
OnRankingsChanged(new DedimaniaRanking[] {});
}
Context.RPCClient.Callbacks.BeginRace += Callbacks_BeginRace;
Context.RPCClient.Callbacks.EndRace += Callbacks_EndRace;
Context.RPCClient.Callbacks.PlayerFinish += Callbacks_PlayerFinish;
}
public static int Comparer(DedimaniaRanking x, DedimaniaRanking y)
{
if (x.TimeOrScore != y.TimeOrScore)
{
return(Convert.ToInt32((int)x.TimeOrScore - (int)y.TimeOrScore));
}
return(x.Created.Ticks < y.Created.Ticks ? -1 : +1);
}
private void FillRankingsFromDedimania(IEnumerable <DedimaniaRecord> records, ICollection <PlayerRank> currentRankings)
{
List <DedimaniaRanking> rankings = new List <DedimaniaRanking>();
foreach (DedimaniaRecord dedimaniaRecord in records)
{
rankings.Add(new DedimaniaRanking(dedimaniaRecord.Login, dedimaniaRecord.Nickname, Convert.ToUInt32(dedimaniaRecord.BestTime.TotalMilliseconds), DateTime.MinValue.AddSeconds(dedimaniaRecord.Rank)));
}
if (currentRankings != null)
{
foreach (PlayerRank playerRank in currentRankings)
{
if (playerRank.BestTime <= 0)
{
continue;
}
string nickname = GetNickname(playerRank.Login);
DedimaniaRanking existingRanking = rankings.Find(ranking => ranking.Login == playerRank.Login);
if (existingRanking != null)
{
if (existingRanking.TimeOrScore != playerRank.BestTime)
{
existingRanking.Created = DateTime.Now.AddMilliseconds(-1 * currentRankings.Count).AddMilliseconds(playerRank.Rank);
}
existingRanking.TimeOrScore = Convert.ToUInt32(playerRank.BestTime);
}
else
{
rankings.Add(new DedimaniaRanking(playerRank.Login, nickname, Convert.ToUInt32(playerRank.BestTime), DateTime.Now.AddMilliseconds(-1 * currentRankings.Count).AddMilliseconds(playerRank.Rank)));
}
}
}
rankings.Sort(DedimaniaRanking.Comparer);
Rankings = rankings.ToArray();
}
private void ReportCurrentChallenge(ICollection <PlayerRank> currentRankings, ChallengeListSingleInfo currentChallenge)
{
if (currentChallenge == null)
{
return;
}
ServerOptions serverOptions = GetServerOptionsCached(this);
if (serverOptions == null)
{
return;
}
GameMode?currentGameMode = GetCurrentGameModeCached(this);
if (!currentGameMode.HasValue)
{
return;
}
List <PlayerSettings> currentPlayers = Context.PlayerSettings.GetAllAsList();
List <PlayerSettings> nonSpectators = currentPlayers.FindAll(player => !player.SpectatorStatus.IsSpectator);
List <DedimaniaPlayerInfo> playersToReport = new List <DedimaniaPlayerInfo>();
foreach (PlayerSettings playerSettings in nonSpectators)
{
playersToReport.Add(new DedimaniaPlayerInfo(playerSettings.Login, string.Empty, string.Empty, playerSettings.TeamID, playerSettings.SpectatorStatus.IsSpectator, playerSettings.LadderRanking, playerSettings.IsInOfficialMode));
}
int playersCount = playersToReport.Count;
int spectatorsCount = currentPlayers.Count - playersCount;
DedimaniaServerInfo serverInfo = new DedimaniaServerInfo(serverOptions.Name, serverOptions.Comment, serverOptions.Password.Length > 0, string.Empty, 0, Context.ServerInfo.ServerXMLRpcPort, playersCount, serverOptions.CurrentMaxPlayers, spectatorsCount, serverOptions.CurrentMaxSpectators, serverOptions.CurrentLadderMode, string.Empty);
DedimaniaCurrentChallengeReply currentChallengeReply = null;
try
{
currentChallengeReply = DedimaniaClient.CurrentChallenge(currentChallenge.UId, currentChallenge.Name, currentChallenge.Environnement, currentChallenge.Author, Context.ServerInfo.Version.GetShortName(), (int)currentGameMode.Value, serverInfo, (int)DedimaniaSettings.MAX_RECORDS_TO_REPORT, playersToReport.ToArray());
IsDedimaniaResponsive = true;
}
catch (Exception ex)
{
Logger.ErrorToUI("Could not report current challenge: " + ex.Message);
Logger.Error("Could not report current challenge: " + ex);
IsDedimaniaResponsive = false;
}
if (currentChallengeReply != null)
{
FillRankingsFromDedimania(currentChallengeReply.Records, currentRankings);
BestTime = Rankings.Length == 0 ? null : (uint?)Rankings[0].TimeOrScore;
}
else
{
Rankings = new DedimaniaRanking[] {};
BestTime = null;
if (IsDedimaniaResponsive)
{
Logger.Debug("Error while calling CurrentChallenge!");
}
}
OnRankingsChanged(Rankings);
}
private void Callbacks_PlayerFinish(object sender, PlayerFinishEventArgs e)
{
if (!IsDedimaniaResponsive)
{
return;
}
RunCatchLog(() =>
{
if (e.TimeOrScore > 0)
{
int rankingIndex = Array.FindIndex(Rankings, rank => rank.Login == e.Login);
DedimaniaRanking ranking = rankingIndex == -1 ? null : Rankings[rankingIndex];
uint?oldRank = null;
uint?newRank = null;
string nickname = null;
if (ranking != null)
{
if (e.TimeOrScore < ranking.TimeOrScore)
{
oldRank = (uint)rankingIndex + 1;
lock (_rankingModifyLock)
{
ranking.TimeOrScore = Convert.ToUInt32(e.TimeOrScore);
List <DedimaniaRanking> newRankings = new List <DedimaniaRanking>(Rankings);
newRankings.Sort(DedimaniaRanking.Comparer);
newRank = (uint)newRankings.IndexOf(ranking) + 1;
Rankings = newRankings.ToArray();
}
}
}
else
{
nickname = GetNickname(e.Login);
if (nickname == null)
{
return;
}
lock (_rankingModifyLock)
{
List <DedimaniaRanking> newRankings = new List <DedimaniaRanking>(Rankings);
DedimaniaRanking newRanking = new DedimaniaRanking(e.Login, nickname, Convert.ToUInt32(e.TimeOrScore), DateTime.Now);
newRankings.Add(newRanking);
newRankings.Sort(DedimaniaRanking.Comparer);
newRank = Convert.ToUInt32(newRankings.IndexOf(newRanking)) + 1;
Rankings = newRankings.ToArray();
}
}
if (newRank.HasValue && newRank <= DedimaniaSettings.MAX_RECORDS_TO_REPORT)
{
if (newRank == 1)
{
BestTime = Convert.ToUInt32(e.TimeOrScore);
}
OnRankingsChanged(Rankings);
nickname = nickname ?? GetNickname(e.Login);
if (nickname == null)
{
return;
}
OnRankChanged(newRank.Value, oldRank, e.Login, nickname, Convert.ToUInt32(e.TimeOrScore));
}
}
}, "Error in Callbacks_PlayerFinish Method.", true);
}
public static SortedList <uint, DedimaniaRanking> GetRankingsToShow(DedimaniaRanking[] rankings, string login, uint maxRecordsToShow, uint maxRecordsToReport)
{
// show at least the top 3
maxRecordsToShow = (uint)Math.Max(Math.Min(Math.Min(maxRecordsToShow, maxRecordsToReport), rankings.Length), 3);
maxRecordsToReport = (uint)Math.Min(rankings.Length, maxRecordsToReport);
// set maxRecordsToShow to amount of existing rankings when the amoutn of rankings is less than the value of maxRecordsToShow
if (rankings.Length < maxRecordsToShow && rankings.Length > 3)
{
maxRecordsToShow = Convert.ToUInt32(rankings.Length);
}
int currentPlayerRankIndex = Array.FindIndex(rankings, ranking => ranking.Login == login);
SortedList <uint, DedimaniaRanking> result = new SortedList <uint, DedimaniaRanking>();
// always add the first 3 records, replace non existing records with empty ones
for (uint i = 1; i <= 3; i++)
{
DedimaniaRanking currentRank = rankings.Length >= i ? rankings[i - 1] : new DedimaniaRanking(string.Empty, string.Empty, 0, DateTime.MinValue);
result.Add(i, currentRank);
}
// leave if no more records left
if (maxRecordsToShow <= 3)
{
return(result);
}
uint amountOfRecordsLeft = maxRecordsToShow - 3;
uint upperLimitLeft = 4 + ((maxRecordsToReport - 3) / 2) + ((maxRecordsToReport - 3) % 2);
uint lowerLimitRight = upperLimitLeft;
if (currentPlayerRankIndex != -1 && currentPlayerRankIndex > 2 && currentPlayerRankIndex < maxRecordsToReport)
{
result.Add((uint)(currentPlayerRankIndex + 1), rankings[currentPlayerRankIndex]);
amountOfRecordsLeft--;
upperLimitLeft = (uint)currentPlayerRankIndex + 1;
lowerLimitRight = (uint)(currentPlayerRankIndex + 2);
}
List <uint> ranksBeforePlayerRank = new List <uint>();
for (uint i = 4; i < upperLimitLeft; i++)
{
ranksBeforePlayerRank.Add(i);
}
List <uint> ranksAfterPlayerRank = new List <uint>();
for (uint i = lowerLimitRight; i <= maxRecordsToReport; i++)
{
ranksAfterPlayerRank.Add(i);
}
uint leftAmount = (amountOfRecordsLeft / 2) + (amountOfRecordsLeft % 2);
uint rightAmount = (amountOfRecordsLeft / 2);
if (leftAmount > ranksBeforePlayerRank.Count)
{
uint diff = leftAmount - (uint)ranksBeforePlayerRank.Count;
leftAmount = (uint)ranksBeforePlayerRank.Count;
rightAmount += diff;
}
if (rightAmount > ranksAfterPlayerRank.Count)
{
uint diff = rightAmount - (uint)ranksAfterPlayerRank.Count;
rightAmount = (uint)ranksAfterPlayerRank.Count;
leftAmount += diff;
}
uint leftAmountStart = leftAmount, leftAmountEnd = 0;
uint rightAmountStart = 0, rightAmountEnd = rightAmount;
if (currentPlayerRankIndex != -1 && currentPlayerRankIndex > 2)
{
leftAmountStart = (leftAmount / 2);
leftAmountEnd = (leftAmount / 2) + (leftAmount % 2);
rightAmountStart = (rightAmount / 2);
rightAmountEnd = (rightAmount / 2) + (rightAmount % 2);
}
for (int i = 0; i < leftAmountStart; i++)
{
result.Add(ranksBeforePlayerRank[i], rankings[ranksBeforePlayerRank[i] - 1]);
}
for (int i = ranksBeforePlayerRank.Count - 1; i > (ranksBeforePlayerRank.Count - 1) - leftAmountEnd; i--)
{
result.Add(ranksBeforePlayerRank[i], rankings[ranksBeforePlayerRank[i] - 1]);
}
for (int i = 0; i < rightAmountStart; i++)
{
result.Add(ranksAfterPlayerRank[i], rankings[ranksAfterPlayerRank[i] - 1]);
}
for (int i = ranksAfterPlayerRank.Count - 1; i > (ranksAfterPlayerRank.Count - 1) - rightAmountEnd; i--)
{
result.Add(ranksAfterPlayerRank[i], rankings[ranksAfterPlayerRank[i] - 1]);
}
return(result);
}
