public void PlayerScoreUpdated(LeaderboardType lbType, int score)
{
if (this.OnPlayerScoreUpdated != null)
{
this.OnPlayerScoreUpdated(lbType, score);
}
}
public static LeaderboardType GetNext(LeaderboardType value)
{
return((from LeaderboardType val in System.Enum.GetValues(typeof(LeaderboardType))
where val > value
orderby val
select val).DefaultIfEmpty().First());
}
public async Task <List <VLeaderboard> > GetTop(LeaderboardType type, LeaderboardTimeType timeType, DateTime date, int page, int records)
{
switch (timeType)
{
case LeaderboardTimeType.AllTime:
date = DateTime.MinValue;
break;
case LeaderboardTimeType.Yearly:
date = new DateTime(date.Year, 1, 1);
break;
case LeaderboardTimeType.Monthly:
date = new DateTime(date.Year, date.Month, 1);
break;
case LeaderboardTimeType.Daily:
date = date.Date;
break;
default:
date = date.Date;
break;
}
var list = await _vset.AsQueryable().Where(p => p.Type == type && p.TimeType == timeType && p.Date == date).Skip(page * records).Take(records).ToListAsync();
return(list);
}
public async Task <List <VLeaderboard> > GetTop(LeaderboardType type, LeaderboardTimeType timeType, DateTime date, int page, int records)
{
using (var ctx = _db.GetDbContext())
{
return(await ctx.Leaderboards.GetTop(type, timeType, date, page, records));
}
}
public async Task <bool> AddAsync(ulong userId, LeaderboardType type, LeaderboardTimeType timeType, long scoreIncrease)
{
using (var ctx = _db.GetDbContext())
{
return(await ctx.Leaderboards.AddAsync(userId, type, timeType, scoreIncrease));
}
}
public async Task RichestCommandAsync(CommandContext ctx, LeaderboardType type)
{
List <Wallet> wallets;
wallets = this._model.Wallets
.AsNoTracking()
.OrderByDescending(x => x.Balance)
.ToList();
if (type == LeaderboardType.Server)
{
var users = await ctx.Guild.GetAllMembersAsync();
wallets = wallets.Where(x => users.Any(y => y.Id == x.UserId)).ToList();
}
int total = 0;
var totalCalc = Task.Run(() => total = wallets.AsParallel().Sum(x => x.Balance));
var interact = ctx.Client.GetInteractivity();
string data = "";
int c = 1;
foreach (var user in wallets)
{
data += $"{c++}. {Formatter.Bold(user.Username == "" ? user.UserId.ToString() : user.Username)} - {user.Balance.ToMoney()}\n";
}
if (data.Count() > 0)
{
data = data[..(data.Count() - 1)];
public async Task ShowLeaderboard(LeaderboardType type = LeaderboardType.Global)
{
if (type == LeaderboardType.Global)
{
var top = _leaderboard.GetTopRank(15);
await ReplyAsync(embed : await FormatLeaderboard(top));
}
else if (type == LeaderboardType.Current)
{
var challenge = await _challenges.GetCurrentChallenge();
if (challenge == null)
{
await ReplyAsync("There is no currently running challenge");
return;
}
await DisplayChallengeLeaderboard(challenge);
}
else if (type == LeaderboardType.Trueskill)
{
var top = _skills.GetTopRanks(15);
await ReplyAsync(embed : await FormatLeaderboard(top));
}
else
{
throw new InvalidOperationException("Unknown leaderboard type");
}
}
public void LeaderboardLoaded(LeaderboardType lbType)
{
if (this.OnLeaderboardLoaded != null)
{
this.OnLeaderboardLoaded(lbType);
}
}
public LeaderboardVO(LeaderboardType type, int totalEntries)
{
this.type = type;
this.HasPlayerEntry = false;
this.playerScore = null;
this.totalEntries = totalEntries;
this.entries = new List <LeaderboardEntryVO>();
}
private Leaderboard(ulong guildId, LeaderboardType type, DiscordBot bot, DateTimeOffset creationTime, TimeSpan timePeriod = default(TimeSpan))
{
TimeGenerated = creationTime;
GuildId = guildId;
Type = type;
TimePeriod = timePeriod;
this.bot = bot;
}
public void ChangeLeaderboardType(LeaderboardType newType)
{
leaderboardType = newType;
title.text = leaderboardType.ToString();
UpdateLeaderboard(leaderboardType);
}
public async Task <IActionResult> Get(string name)
{
var gamertag = User.GetGamerTag();
_appMonitor.LogEvent("Leaderboard", properties: new Dictionary <string, string> {
{ "Name", name }
});
LeaderboardConfig config = _leaderboardProvider.GetByName(name);
if (config == null)
{
return(NotFound());
}
LeaderboardType type = config.Type;
List <GameScore> scores;
switch (type)
{
case LeaderboardType.AroundMe:
if (gamertag == null)
{
return(this.ValidationFailed(new ErrorDetail("gamertag", "Must be signed in as a player with a gamertag to retrive this leaderboard")));
}
scores = await _store.GetScoresAroundMeAsync(gamertag, config.Radius);
break;
case LeaderboardType.Top:
scores = await _store.GetTopHighScoresAsync(config.Top);
break;
default:
scores = await _store.GetAllHighScoresAsync();
break;
}
GameScore currentPlayer = null;
if (config.IncludeCurrentPlayer && gamertag != null)
{
currentPlayer = (await _store.GetScoresAroundMeAsync(gamertag, 0)).FirstOrDefault();
}
// Format response model
var resultModel = new LeaderboardGetResponseModel
{
Entries = scores
?.Select(s => LeaderboardGetResponseModel.LeaderboardEntry.Map(s, gamertag))
?.ToList(),
CurrentPlayer = LeaderboardGetResponseModel.LeaderboardEntry.Map(currentPlayer, null)
};
// Return result
return(Ok(resultModel));
}
public void CanGetGameDataByLeaderboardType(EvaluationDataType dataType, LeaderboardType leaderboardType, string expectedValue)
{
var loggedInAccount = Helpers.CreateAndLoginGlobal(Fixture.SUGARClient, GameDataClientTestsLeaderboardKey);
var game = Helpers.GetGame(Fixture.SUGARClient.Game, GameDataClientTestsLeaderboardKey);
var get = Fixture.SUGARClient.GameData.GetByLeaderboardType(loggedInAccount.User.Id, game.Id, GameDataClientTestsLeaderboardKey, dataType, leaderboardType);
Assert.Equal(expectedValue, get.Value);
}
private void onLeaderboardOutperformed(LeaderboardType leaderboardType)
{
Player player = GameLogic.Binder.GameState.Player;
if ((leaderboardType == LeaderboardType.Royal) && !player.TrackingData.PerSessionWasOutperformed)
{
player.TrackingData.PerSessionWasOutperformed = true;
this.sendCrmEvent(player, "crm_leaderboard_beaten");
}
}
public Leaderboard(string id = "leaderboard", int amount = 100, LeaderboardType type = LeaderboardType.HIGH_TO_LOW, bool persistOnInstantiate = true)
{
_id = id;
_type = type;
Initialize(amount);
if (persistOnInstantiate)
{
Save();
}
}
public async Task <IActionResult> Get(string name)
{
var gamertag = User.GetGamerTag();
LeaderboardConfig config = _leaderboardConfiguration.GetByName(name);
if (config == null)
{
return(NotFound());
}
LeaderboardType type = config.Type;
List <GameScore> scores;
switch (type)
{
case LeaderboardType.AroundMe:
if (gamertag == null)
{
return(BadRequest()); // need a gamertag to get scores!
}
scores = await _store.GetScoresAroundMeAsync(gamertag, config.Radius);
break;
case LeaderboardType.Top:
scores = await _store.GetTopHighScoresAsync(config.Top);
break;
default:
scores = await _store.GetAllHighScoresAsync();
break;
}
GameScore currentPlayer = null;
if (config.IncludeCurrentPlayer && gamertag != null)
{
currentPlayer = (await _store.GetScoresAroundMeAsync(gamertag, 0)).FirstOrDefault();
}
// Format response model
var resultModel = new LeaderboardGetResponseModel
{
Entries = scores
?.Select(s => LeaderboardGetResponseModel.LeaderboardEntry.Map(s, gamertag))
?.ToList(),
CurrentPlayer = LeaderboardGetResponseModel.LeaderboardEntry.Map(currentPlayer, null)
};
// Return result
return(Ok(resultModel));
}
/// <summary>
/// Posts a score to the specified leaderboard.
/// </summary>
/// <param name="score">The score to post.</param>
/// <param name="leaderboard">The leaderboard to post to.</param>
/// <param name="reportScoreFinishedDelegate">The event handler for when report score finishes.</param>
public void PostScoreToLeaderboard(int score, LeaderboardType leaderboard, System.Action <bool> reportScoreFinishedDelegate)
{
if (leaderboard == LeaderboardType.SIZE)
{
return;
}
if (!IsSignedInToGoogle)
{
return;
}
Social.ReportScore(score, m_leaderboards.GetID(leaderboard), reportScoreFinishedDelegate);
}
private static Dictionary <string, LeaderboardConfig> GetLeaderboardConfiguration(IConfigurationSection configuration)
{
Dictionary <string, LeaderboardConfig> leaderboards = new Dictionary <string, LeaderboardConfig>();
// go over all leaderboards under "Leaderboard:Leaderboards"
foreach (var config in configuration.GetChildren())
{
string name = config.Key;
bool includeCurrentPlayer = bool.Parse(config["IncludeCurrentPlayer"] ?? "false");
LeaderboardType type = (LeaderboardType)Enum.Parse(typeof(LeaderboardType), config["Type"]);
LeaderboardConfig leaderboardConfig = new LeaderboardConfig
{
Name = name,
Type = type,
IncludeCurrentPlayer = includeCurrentPlayer
};
switch (type)
{
case LeaderboardType.Top:
string top = config["Top"];
if (top == null)
{
throw new Exception($"Leaderboard type Top must have Top value set. Leaderboard name: '{name}'");
}
else
{
leaderboardConfig.Top = int.Parse(top);
}
break;
case LeaderboardType.AroundMe:
string radius = config["Radius"];
if (radius == null)
{
throw new Exception($"Leaderboard type AroundMe must have Radius value set. Leaderboard name: '{name}'");
}
else
{
leaderboardConfig.Radius = int.Parse(radius);
}
break;
case LeaderboardType.All:
break;
}
leaderboards.Add(name, leaderboardConfig);
}
return(leaderboards);
}
public async Task TestLeaderboard(GameMode mode, LeaderboardType type, uint expectedUser, uint pages = 1)
{
OsuUserLeaderboard leaderboard = null;
do
{
leaderboard = await Client.GetLeaderboard(mode, type, last : leaderboard);
pages--;
} while (pages > 0);
Assert.IsTrue(leaderboard.Ranking.Select(x => x.User?.Id).Contains(expectedUser));
}
/// <summary>
/// Shows the UI for the specified leaderboard.
/// </summary>
/// <param name="leaderboard">The leaderboard.</param>
/// <returns>Whether leaderboard UI was shown</returns>
public bool ShowLeaderboardUI(LeaderboardType leaderboard)
{
if (leaderboard == LeaderboardType.SIZE)
{
return(false);
}
if (!IsSignedInToGoogle)
{
return(false);
}
PlayGamesPlatform.Instance.ShowLeaderboardUI(m_leaderboards.GetID(leaderboard));
return(true);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
LeaderboardType leaderboardType = (Session["LeaderboardType"] != null ? (LeaderboardType)Session["LeaderboardType"] : LeaderboardType.Monthly);
PlaylistType playlistType = (Session["PlaylistType"] != null ? (PlaylistType)Session["PlaylistType"] : PlaylistType.Standard);
SqlDataSource source = (leaderboardType == LeaderboardType.AllTime ? AllTimeDataSource : MonthlyDataSource);
source.ConnectionString = Database.GetSqlConnection().ConnectionString;
source.SelectParameters.Add("Playlist", ((int)playlistType).ToString());
gvLeaderboard.DataSource = source;
gvLeaderboard.DataBind();
}
}
public void LoadLeaderboard(LeaderboardType type)
{
SortLeaderboards();
string leaderboard = "";
switch (type)
{
case LeaderboardType.MostWins:
leaderboard = "<b><size=50>Most Wins</size></b>\n";
for (int i = 0; i < 10; i++)
{
leaderboard += (i + 1) + ". ";
if (mostWins.Count > i)
{
string id = mostWins.ElementAt(i).Key;
string displayName = tc.GetDisplayName(id).Result;
leaderboard += displayName + " - " + mostWins[id];
}
if (i != 10)
{
leaderboard += "\n";
}
}
break;
case LeaderboardType.MostGuesses:
leaderboard = "<b><size=50>Most Guesses</size></b>\n";
for (int i = 0; i < 10; i++)
{
leaderboard += (i + 1) + ". ";
if (mostGuesses.Count > i)
{
string id = mostGuesses.ElementAt(i).Key;
string displayName = tc.GetDisplayName(id).Result;
leaderboard += displayName + " - " + mostGuesses[id];
}
if (i != 10)
{
leaderboard += "\n";
}
}
break;
case LeaderboardType.MostAccurate:
break;
}
StartCoroutine(changeLeaderboardInfoText(leaderboard, type));
}
private static Dictionary <string, LeaderboardConfig> GetLeaderboardconfiguraion(IEnumerable <IConfigurationSection> enumerable)
{
Dictionary <string, LeaderboardConfig> leaderboards = new Dictionary <string, LeaderboardConfig>();
// go over all leaderboards under "Leaderboard:Leaderboards"
foreach (var config in enumerable)
{
string name = config["Name"];
LeaderboardType type = (LeaderboardType)Enum.Parse(typeof(LeaderboardType), config["Type"]);
LeaderboardConfig leaderboardConfig = new LeaderboardConfig
{
Name = name,
Type = type
};
switch (type)
{
case LeaderboardType.Top:
string top = config["Top"];
if (top == null)
{
throw new Exception($"Leaderboard type Top must have Top value set. Leaderboard name: '{name}'");
}
else
{
leaderboardConfig.Top = int.Parse(top);
}
break;
case LeaderboardType.AroundMe:
string radius = config["Radius"];
if (radius == null)
{
throw new Exception($"Leaderboard type AroundMe must have Radius value set. Leaderboard name: '{name}'");
}
else
{
leaderboardConfig.Radius = int.Parse(radius);
}
break;
case LeaderboardType.All:
break;
}
leaderboards.Add(name, leaderboardConfig);
}
return(leaderboards);
}
/// <summary>
/// Get the top count players/clubs/brawlers.
/// </summary>
/// <param name="type">Type of leaderboard.</param>
/// <param name="count">The number of top players or clubs to fetch. If count > 200, it will return a ValueError.</param>
public async Task <Leaderboard[]> GetLeaderboardAsync(LeaderboardType type, int count)
{
string s = Utils.LeaderboardToString(type);
bool isbrawler = (int)type > 1;
string req = $"{Utils.Leaderboard}/{(isbrawler ? "players" : s)}?count={count}{(isbrawler ? "&brawler=" + type : "")}";
HttpResponseMessage response = await client.GetAsync(req);
if (response.IsSuccessStatusCode)
{
var json = await response.Content.ReadAsStringAsync();
return(Leaderboard.FromJson(json));
}
return(null);
}
/// <inheritdoc />
/// <summary>
/// </summary>
/// <param name="type"></param>
/// <param name="text"></param>
public LeaderboardSelectorItemRankings(LeaderboardType type, string text) :
base(text, type == ConfigManager.LeaderboardSection.Value)
{
Type = type;
ConfigManager.LeaderboardSection.ValueChanged += OnLeaderboardSectionChange;
Clicked += (sender, args) =>
{
if (ConfigManager.LeaderboardSection.Value == Type)
{
return;
}
ConfigManager.LeaderboardSection.Value = Type;
};
}
private void GetByLeaderboardType(string key, EvaluationDataType dataType, LeaderboardType type, Action <EvaluationDataResponse> onComplete)
{
if (SUGARManager.UserSignedIn)
{
SUGARManager.client.GameData.GetByLeaderboardTypeAsync(SUGARManager.CurrentUser.Id, SUGARManager.GameId, key, dataType, type,
onComplete,
exception =>
{
Debug.LogError(exception);
onComplete(null);
});
}
else
{
onComplete(null);
}
}
public void GetLeaderboardByType(LeaderboardType type, int numberOfEntries)
{
switch (type)
{
case LeaderboardType.GLOBAL:
GetGlobalLeaderboard(numberOfEntries);
break;
case LeaderboardType.AROUND_ME:
GetAroundMeLeaderboard(numberOfEntries);
break;
case LeaderboardType.FRIENDS:
GetFriendsLeaderboard(numberOfEntries);
break;
}
}
IEnumerator changeLeaderboardInfoText(string newtext, LeaderboardType type)
{
if (leaderboardType == type)
{
Leaderboard.text = newtext;
}
else
{
leaderboardType = type;
var start = -835;
var destination = -1605;
yield return(moveGui(destination));
Leaderboard.text = newtext;
yield return(moveGui(start));
}
}
public void ChangeLeaderBoardType(int index)
{
leaderboardType = (LeaderboardType)index;
for (int i = 0; i < leaderBoardTypeList.Count; i++)
{
if (i == index)
{
leaderBoardTypeList[i].DOFade(1, 0.3f);
}
else
{
leaderBoardTypeList[i].DOFade(0.6f, 0.2f);
}
}
ShowHighScore();
}
public static string LeaderboardToString(LeaderboardType type)
{
int t = (int)type;
int i = t - 2;
if (i >= 0)
{
return(Brawlers[i]);
}
else if (t >= 0 && t <= 1)
{
return(type.ToString().ToLower());
}
else
{
return(null);
}
}
