public Ranking(PointSystem system, Club[] clubs)
{
_system = system;
_entries = new RankingEntry[clubs.Length];
for (int i = 0; i < clubs.Length; i++)
_entries[i] = new RankingEntry(clubs[i], system.InitialPoints);
}
public async Task <IActionResult> SetRank(Uri uri, float rankValue, [FromServices] ApplicationDbContext db)
{
var rankedSite = await db.RankedSites.FirstOrDefaultAsync(x => x.Uri == uri);
if (rankedSite == null)
{
rankedSite = new RankedSite
{
Uri = uri,
Ignore = false,
};
db.Add(rankedSite);
}
await db.SaveChangesAsync();
var rank = await db.Rankings.FirstOrDefaultAsync(x => x.RankedSiteId == uri);
if (rank == null)
{
rank = new RankingEntry
{
RankedSiteId = uri,
RankingUserId = this.User.Claims.First(x => x.Type == System.Security.Claims.ClaimTypes.NameIdentifier).Value,
};
db.Add(rank);
}
rank.Rank = rankValue;
await db.SaveChangesAsync();
return(Ok());
}
internal static PlayerDetailsViewData ToPlayerDetailsViewData(this RankingEntry entry, string imagePath)
{
var localDetails = new Dictionary <Stage, IReadOnlyDictionary <Level, (int, int, long?, DateTime?)> >();
foreach (var stage in entry.Game.GetStages())
{
localDetails.Add(stage, entry.Details.ContainsKey(stage) ? entry.Details[stage] : null);
}
return(new PlayerDetailsViewData
{
DetailsByStage = localDetails.Keys.Select(sk => localDetails[sk].ToPlayerStageDetailsItemData(sk, imagePath)).ToList(),
EasyPoints = entry.LevelPoints[Level.Easy],
EasyTime = new TimeSpan(0, 0, (int)entry.LevelCumuledTime[Level.Easy]),
Game = entry.Game,
HardPoints = entry.LevelPoints[Level.Hard],
HardTime = new TimeSpan(0, 0, (int)entry.LevelCumuledTime[Level.Hard]),
MediumPoints = entry.LevelPoints[Level.Medium],
MediumTime = new TimeSpan(0, 0, (int)entry.LevelCumuledTime[Level.Medium]),
OverallPoints = entry.Points,
OverallRanking = entry.Rank,
OverallTime = new TimeSpan(0, 0, (int)entry.CumuledTime),
PlayerName = entry.Player.RealName
});
}
private static RankingEntry FindRankingEntryToDelete(long rankingEntryId)
{
RankingEntry rankingEntry = RankingEntries.FirstOrDefault(r => r.RankingEntryId == rankingEntryId);
if (rankingEntry == null)
{
throw new RankingEntryNotFoundException($"Contestant with id {rankingEntryId} in ranking not found!");
}
return(rankingEntry);
}
public static void AddRankingEntry(Contestant contestant, Route route)
{
RankingEntry rankingEntry = FindRankingEntryToUpdate(contestant.ContestantId);
if (rankingEntry != null)
{
rankingEntry.PointsSum += route.Points;
rankingEntry.ContestantRoutes.Add(route.RouteName);
}
else
{
rankingEntry = new RankingEntry(contestant, route);
RankingEntries.Add(rankingEntry);
}
}
private string StringifyEntryProperty(RankingEntry entry, string propertyName)
{
var propertyValue = entry.GetProperty(propertyName);
switch (propertyValue)
{
case string str:
return(str);
case int integer:
return(integer.ToString());
case IRating rating:
return(rating.HasValue ? rating.Value !.ToString() ! : "-");
default:
return(propertyName == "rank" ? "-" : string.Empty);
}
}
public void BuildList()
{
if (ranking == null)
{
ranking = FindObjectOfType <Ranking>();
}
foreach (Transform child in list.transform)
{
GameObject.Destroy(child.gameObject);
}
for (int i = 0; i < ranking.List.Count; i++)
{
if (i > MaxEntries)
{
break;
}
RankingEntry entry = Instantiate(entryPrefab, list.transform).GetComponent <RankingEntry>();
entry.Initialize(ranking.List[i].Name, (i + 1).ToString(), ranking.List[i].Score.ToString());
}
}
public async Task ExecuteAsync(NewRankingSnapshotEvent @event)
{
RankingSnapshot rankingSnapshot = await _repository.GetAsync(@event.Id);
List <RankingEntry> ordered = rankingSnapshot.RankingEntries.OrderByDescending(entry => entry.Score).ToList();
for (var i = 0; i < ordered.Count; i++)
{
RankingEntry entry = ordered[i];
// This could be batched if we assume that every user is in the ranking.
IEnumerable <Profile> profiles = await _userManagementClient.ApiUserGetAsync(entry.UserId);
Profile profile = profiles.Single();
entry.Rank = i + 1;
entry.UserFirstName = profile.FirstName;
entry.UserLastName = profile.LastName;
entry.UserNickname = profile.Nickname;
entry.UserGravatarHash = GravatarHashCreator.HashEmailForGravatar(profile.Email);
}
await _repository.UpdateAsync(@event.Id, snapshot => snapshot.RankingEntries = rankingSnapshot.RankingEntries);
}
/// <summary>
/// Almacena la informacion del usuario local en el ranking
/// </summary>
/// <param name="_posUsuarioLanzador"></param>
/// <param name="_posUsuarioPortero"></param>
/// <param name="_posUsuarioMultiplayer"></param>
public void SetInfoPosUsuario(RankingEntry _posUsuarioLanzador, RankingEntry _posUsuarioPortero, RankingEntry _posUsuarioMultiplayer)
{
m_posUsuarioLanzador = _posUsuarioLanzador;
m_posUsuarioPortero = _posUsuarioPortero;
m_posUsuarioMultiplayer = _posUsuarioMultiplayer;
}
public IPromise <(int, List <RankingEntry>)> GetLevelRankings(string levelId, string chartType)
{
var entries = new List <RankingEntry>();
var top10 = new List <RankingEntry>();
if (IsAuthenticated)
{
return(RestClient.GetArray <RankingEntry>(new RequestHelper
{
Uri = $"{Context.ApiUrl}/levels/{levelId}/charts/{chartType}/records?limit=10",
Headers = GetRequestHeaders(),
EnableDebug = true
})
.Then(data =>
{
top10 = data.ToList();
// Add the first 3
entries.AddRange(top10.GetRange(0, Math.Min(3, top10.Count)));
return RestClient.GetArray <RankingEntry>(new RequestHelper
{
Uri =
$"{Context.ApiUrl}/levels/{levelId}/charts/{chartType}/user_ranking?limit=6",
Headers = GetRequestHeaders(),
EnableDebug = true
});
})
.Then(data =>
{
var list = data.ToList();
// Find user's position
var userRank = -1;
RankingEntry userEntry = null;
for (var index = 0; index < data.Length; index++)
{
var entry = data[index];
if (entry.owner.Uid == Context.Player.Id)
{
userRank = entry.rank;
userEntry = entry;
break;
}
}
if (userRank == -1 || userRank <= 10)
{
// Just use top 10
entries = top10;
}
else
{
// Add previous 6 and next 6, and remove accordingly
var append = new List <RankingEntry>();
append.AddRange(list);
append.RemoveRange(0, Math.Max(3, Math.Max(0, 10 - userRank)));
if (append.Count > 7)
{
append.RemoveRange(7, append.Count - 7);
}
entries.AddRange(append);
}
if (userEntry != null)
{
// Replace local performance only if higher or equal score
var record = Context.Database.GetLevelRecord(levelId);
if (record == null || !record.BestPerformances.ContainsKey(chartType) ||
record.BestPerformances[chartType].Score < userEntry.score ||
(record.BestPerformances[chartType].Score == userEntry.score && record.BestPerformances[chartType].Accuracy < userEntry.accuracy))
{
if (record == null)
{
record = new LevelRecord
{
LevelId = levelId
}
}
;
var newBest = new LevelRecord.Performance
{
Score = userEntry.score,
Accuracy = userEntry.accuracy
};
record.BestPerformances[chartType] = newBest;
Context.Database.SetLevelRecord(record);
if (Context.LevelManager.LoadedLocalLevels.ContainsKey(levelId))
{
Context.LevelManager.LoadedLocalLevels[levelId].Record = record;
}
OnLevelBestPerformanceUpdated.Invoke(levelId);
Debug.Log("Updating: " + levelId);
}
}
return (userRank, entries);
}));
}
return(RestClient.GetArray <RankingEntry>(new RequestHelper
{
Uri = $"{Context.ApiUrl}/levels/{levelId}/charts/{chartType}/records",
EnableDebug = true,
}).Then(array => (-1, array.ToList())));
}
public static void DeleteRankingEntry(long rankingEntryId)
{
RankingEntry rankingEntry = FindRankingEntryToDelete(rankingEntryId);
RankingEntries.Remove(rankingEntry);
}
public string FormatEntry(RankingEntry rankingEntry)
{
var values = ValueSelectors.Select(selector => selector(rankingEntry)).ToArray();
return(string.Format(Format, values));
}
