private XElement GetPlayerRecordElement(PlayerRank rankingInfo, double currentY, uint currentRank, string login)
{
string templateXML = Settings.RankingTemplate;
if (rankingInfo.Login == login)
{
templateXML = Settings.RankingHighlightTemplate;
}
else if (currentRank <= 3)
{
templateXML = Settings.RankingTop3RecordTemplate;
}
TimeSpan time = TimeSpan.FromMilliseconds(rankingInfo.BestTime);
StringBuilder playerRecordXml = new StringBuilder(templateXML);
playerRecordXml.Replace("{[Y]}", currentY.ToString(CultureInfo.InvariantCulture));
playerRecordXml.Replace("{[Rank]}", currentRank + ".");
playerRecordXml.Replace("{[TimeOrScore]}", rankingInfo.BestTime <= 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()));
}
public void SetRank(PlayerRank _player)
{
if (isOpen)
{
return;
}
_Players[_player._Name] = _player;
if (_MultiLapMode == true)
{
IOrderedEnumerable <KeyValuePair <string, PlayerRank> > _SortedPlayers = _Players.OrderBy(_x => _x.Value._RankGive).OrderBy(_x => _x.Value._DistanceToWaypoint).OrderByDescending(_x => _x.Value._ActiveWaypointIndex).OrderByDescending(_x => _x.Value._MultiLapWaypointIndex);
int _i = 0;
foreach (KeyValuePair <string, PlayerRank> _item in _SortedPlayers)
{
_RankText[_i].transform.GetChild(0).GetComponent <Text>().text = (_i + 1) + " . " + _item.Value._Name;
_i++;
}
return;
}
if (_MultiLapMode == false)
{
IOrderedEnumerable <KeyValuePair <string, PlayerRank> > _SortedPlayers = _Players.OrderBy(_x => _x.Value._RankGive).OrderBy(_x => _x.Value._DistanceToWaypoint).OrderByDescending(_x => _x.Value._ActiveWaypointIndex);
int _i = 0;
foreach (KeyValuePair <string, PlayerRank> _item in _SortedPlayers)
{
_RankText[_i].transform.GetChild(0).GetComponent <Text>().text = (_i + 1) + " . " + _item.Value._Name;
_i++;
}
return;
}
}
protected void OnPlayerWins(PlayerRank rankingInfo, uint wins)
{
if (PlayerWins != null)
{
PlayerWins(this, new PlayerWinEventArgs(rankingInfo, wins));
}
}
public void ItRecordsAGamePlayedEvent()
{
var playerRank = new PlayerRank
{
GameRank = 1,
PlayerId = 1
};
var newlyCompletedGame = new NewlyCompletedGame
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = new List <PlayerRank>
{
playerRank
}
};
var transactionSource = TransactionSource.RestApi;
autoMocker.Get <IPointsCalculator>()
.Expect(mock => mock.CalculatePoints(null, null))
.IgnoreArguments()
.Return(new Dictionary <int, PointsScorecard>
{
{ playerRank.PlayerId, new PointsScorecard() }
});
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, transactionSource, currentUser);
autoMocker.Get <INemeStatsEventTracker>().AssertWasCalled(mock => mock.TrackPlayedGame(currentUser, transactionSource));
}
private string ParseGroup(PlayerRank group)
{
switch (group)
{
case PlayerRank.Administrateurs:
return("♛Administrateurs");
case PlayerRank.Robots:
return("☎");
case PlayerRank.Moderateurs:
return("♝Modérateurs");
case PlayerRank.Animateurs:
return("♞Animateurs");
case PlayerRank.Developpeurs:
return("♣Développeur");
case PlayerRank.Rulers:
return("♟Rullers");
default:
return(group.ToString());
}
}
private void RankPlayersRPC(Dictionary <int, int> playerScores)
{
List <AoAPlayer> aoaPlayers = new List <AoAPlayer>();
// aoaPlayers = GameController.Instance.UpdatePlayers();
aoaPlayers = _gameController.UpdatePlayers();
int rank = 1;
_playerRankingScreen.SetActive(true);
Debug.Log("Sorting Players by fruit collected");
foreach (KeyValuePair <int, int> score in playerScores)
{
aoaPlayers.Find(p => p.Player.ActorNumber == score.Key)?.SetCount(score.Value);
}
aoaPlayers = aoaPlayers.OrderByDescending(p => p.FruitCount).ToList();
foreach (AoAPlayer player in aoaPlayers)
{
GameObject rankingGO = PhotonNetwork.Instantiate(_playerRankPrefab.name, transform.position, Quaternion.identity);
rankingGO.transform.SetParent(_playerRankings.transform);
rankingGO.transform.localScale = Vector3.one;
PlayerRank pr = rankingGO.GetComponent <PlayerRank>();
//scoreKeeper.UpdateRoundScore(player.Player.ActorNumber, player.FruitCount);
//pr.Initialize(rank, player.Name, scoreKeeper.GetStoredScore(player.Player.ActorNumber), player.Model);
//pr.Initialize(rank, player.Name, playerScores[player.Player.ActorNumber], player.Model);
pr.Initialize(rank, player.Name, player.FruitCount, player.Model);
rank++;
}
}
public void ReadFromStream(SerializationReader r)
{
UserId = r.ReadInt32();
if (UserId < 0)
{
UserId = -UserId;
}
else
{
UsesOsuClient = UserId != 0;
}
Username = r.ReadString();
Timezone = r.ReadByte() - 24;
CountryCode = r.ReadByte();
byte permissionPlaymodeBitfield = r.ReadByte();
Permissions = (PlayerRank)(permissionPlaymodeBitfield & 0b00011111);
PlayMode = (byte)((permissionPlaymodeBitfield & 0b11100000) >> 5);
Longitude = r.ReadSingle();
Latitude = r.ReadSingle();
Rank = r.ReadInt32();
}
public string ParseUsername(string username, PlayerRank rank, bool isVip)
{
/*switch (rank)
* {
* case PlayerRank.Owner:
* return "♛" + username;
* case PlayerRank.Bot:
* return "☎" + username;
* case PlayerRank.Moderateurs:
* return "♝" + username;
* case PlayerRank.Animateurs:
* return "♞" + username;
* case PlayerRank.Developper:
* return "♣" + username;
* case PlayerRank.Contributor:
* return "♟" + username;
* default: */
if (isVip)
{
return("✮" + username);
}
else
{
return(username);
}
}
public void ReadFromStream(SerializationReader r)
{
OsuVersion = r.ReadInt32();
FolderCount = r.ReadInt32();
AccountUnlocked = r.ReadBoolean();
AccountUnlockDate = r.ReadDateTime();
AccountName = r.ReadString();
Beatmaps = new List <BeatmapEntry>();
int length = r.ReadInt32();
for (int i = 0; i < length; i++)
{
int currentIndex = (int)r.BaseStream.Position;
int entryLength = r.ReadInt32();
Beatmaps.Add(BeatmapEntry.ReadFromReader(r, false, OsuVersion));
if (r.BaseStream.Position != currentIndex + entryLength + 4)
{
Debug.Fail($"Length doesn't match, {r.BaseStream.Position} instead of expected {currentIndex + entryLength + 4}");
}
}
AccountRank = (PlayerRank)r.ReadByte();
}
public async Task <bool> SavePlayerRanks(List <PlayerRankSaveDTO> playerRanksToSaveDto)
{
//same player,user
var user = await _userRepository.GetUserById(playerRanksToSaveDto[0].UserId);
var player = await _playerRepository.GetPlayerById(playerRanksToSaveDto[0].PlayerId);
foreach (var playerRank in playerRanksToSaveDto)
{
//Create Mode
if (playerRank.Id == 0)
{
//different skill
var skill = await _skillRepository.GetSkillById(playerRank.SkillId);
PlayerRank prank = new PlayerRank()
{
Player = player,
Rank = playerRank.Rank,
Skill = skill,
User = user
};
await _repository.SavePlayerRank(prank);
}
//Update Mode
else
{
await _repository.UpdatePlayerRankToSave(playerRank);
}
}
//Saving one time in the end
return(await _repository.SaveChangesAsync());
}
public Player(int age, string firstName, string lastName, PlayerRank rank)
{
FirstName = firstName;
LastName = lastName;
Rank = rank;
Age = age;
}
/// <summary>
/// Updates the game HUD.
/// </summary>
/// <param name="score">The player's score.</param>
/// <param name="lives">The player's lives remaining.</param>
/// <param name="rank">The player's rank.</param>
public void UpdateHUD(int score, int lives, PlayerRank rank)
{
scoreText.text = string.Format(LocalizationManager.Instance.GetString("HUD Score"), score.ToString());
livesText.text = string.Format(LocalizationManager.Instance.GetString("HUD Lives"), lives.ToString());
string rankKey = "Rank " + rank.ToString();
rankText.text = string.Format(LocalizationManager.Instance.GetString("HUD Rank"), LocalizationManager.Instance.GetString(rankKey));
}
/// <summary>
/// ゲームの結果を追加
/// </summary>
/// <param name="rank"></param>
public void AddGameResult(PlayerRank rank)
{
int tmp = TotalPoint;
int p = 0;
_counts.TryGetValue(rank, out p);
_counts[rank] = ++p;
RoundPoint = tmp == 0 ? TotalPoint : tmp - TotalPoint;
}
public static void RankPlayer(this DatabaseManager database, PlayerRank playerRank)
{
string sql = "INSERT INTO dbo.PlayerRanks (PlayerId, RankId, ValidUntil) VALUES (@PlayerId, @RankId, @ValidUntil);";
using (var conn = database.connection)
{
conn.Execute(sql, playerRank);
}
}
private static string GetRankCodeAfterDom(PlayerRank rank)
{
var rankName = rank.GetDescription();
var words = rankName.Split(" ");
return(words.Length == 1
? words.Last().Substring(0, 3)
: string.Concat(words.First().AsSpan(0, 1), words.Last().AsSpan(0, 3)));
}
void Awake()
{
territories = GameObject.FindGameObjectWithTag("Territories");
playerRank = territories.GetComponent <PlayerRank> ();
boardSetUp = territories.GetComponent <BoardSetUp> ();
scriptHolder = GameObject.FindGameObjectWithTag("ScriptHolder");
allocateSoldiers = scriptHolder.GetComponent <AllocateSoldiers> ();
teamChecker = scriptHolder.GetComponent <TeamChecker> ();
}
private void AddCommand(string name, string description, PlayerRank rank, bool privatemessage = false)
{
_commands.Add(new Command
{
Name = name,
Description = description,
Rank = rank,
PrivateMessage = privatemessage
});
}
public Sprite BuildPlayerRank(PlayerRank PlayerRank, float LayerDepth)
{
Sprite spr = new Sprite("Interface/Rank/Horizontal",
layerDepth: LayerDepth,
sourceRectangle: RankIconDictionary[PlayerRank]);
spr.Pivot = new Vector2(27 / 2, 17 / 2);
return(spr);
}
public Tech(string name, string description, List <Tech> techRequirements, string color, int cost, List <Blueprint> blueprints = null, PlayerRank rankRequirement = null)
{
Name = name;
Description = description;
TechRequirements = techRequirements;
Color = color;
Cost = cost;
RankRequirement = rankRequirement;
Blueprints = blueprints ?? new List <Blueprint>();
}
void Awake()
{
playerRank = this.GetComponent <PlayerRank> ();
troopRank = this.GetComponent <TroopRank> ();
territoryRank = this.GetComponent <TerritoryRank> ();
soldierBonusRank = this.GetComponent <SoldierBonusRank> ();
scriptHolder = GameObject.FindGameObjectWithTag("ScriptHolder");
phases = scriptHolder.GetComponent <Phases> ();
}
void Awake()
{
troopCount = this.GetComponent <TroopCount> ();
territoryCount = this.GetComponent <TerritoryCount> ();
territoryBonus = this.GetComponent <TerritoryBonus> ();
continentBonus = this.GetComponent <ContinentBonus> ();
soldierBonus = this.GetComponent <SoldierBonus> ();
playerRank = this.GetComponent <PlayerRank> ();
boardSetUp = this.GetComponent <BoardSetUp> ();
}
/// <summary>
/// Call this function when a bee returns to the beehive.
/// </summary>
public void OnBeeArrived()
{
// We only count bee arrivals during gameplay.
if (CanPlay())
{
// Update the player score and rank and refresh the HUD.
score++;
rank = LevelManager.Instance.GetRank(score);
UIManager.Instance.UpdateHUD(score, lives, rank);
}
}
public string AddToRankingList(int score, string name)
{
//UUID - GUILD - unique identifer id
string id = Guid.NewGuid().ToString();//convert to string so unity can serialize and save it on .json file
PlayerRank newPlayer = new PlayerRank(name, score, id);
this._rankingList.Add(newPlayer);
this._rankingList.Sort();
this.Save();
return(id);
}
/// <summary>
/// Get rank by points
/// </summary>
/// <param name="points"></param>
/// <returns></returns>
private PlayerRank rankByPoints(float points)
{
foreach (PlayerRank ranking in PlayerRank.Values())
{
if (ranking.IsInRange(points))
{
return(ranking);
}
}
throw new System.ArgumentException("Cant calculate points => " + points);
}
void Start()
{
// Reset the player's progress.
lives = maxLives;
score = 0;
rank = LevelManager.Instance.GetRank(score);
// Refresh the HUD and show the tutorial screen.
UIManager.Instance.UpdateHUD(score, lives, rank);
UIManager.Instance.ShowHUD(false);
UIManager.Instance.ShowScreen("Tutorial");
}
public static ConsoleColor RankToColor(PlayerRank rank)
{
return(rank switch
{
PlayerRank.Freeman => FreemanColor,
PlayerRank.Huskarl => HuskarlColor,
PlayerRank.Gothi => GothiColor,
PlayerRank.Hirdman => HirdmanColor,
PlayerRank.Thegn => ThegnColor,
PlayerRank.Jarl => JarlColor,
PlayerRank.Konungr => KonungrColor,
_ => ConsoleColor.White
});
public LeaderboardEntry(int leaderboardPlacing, string username, string region, PlayerRank rank, long score, int tagLine, int profilePicture)
{
this.leaderboardPlacing = leaderboardPlacing;
this.rank = rank;
this.username = username;
this.region = region;
this.score = score;
this.tagLine = tagLine;
this.profilePicture = profilePicture;
}
public LeaderboardEntry(PlayerEntity playerEntity)
{
this.leaderboardPlacing = 0;
this.rank = playerEntity.rank;
this.username = playerEntity.username;
this.region = playerEntity.region;
this.tagLine = playerEntity.tagLine;
this.profilePicture = playerEntity.profilePicture;
this.score = playerEntity.battlePoints;
}
protected override void Init()
{
PodiumStage = false;
Settings = LiveRankingsSettings.ReadFromFile(PluginSettingsFilePath);
LastRankings = new PlayerRank[] {};
UpdateUI(this);
UpdateTimer = new TimedVolatileExecutionQueue <LiveRankingPlugin>(TimeSpan.FromSeconds(Settings.UpdateInterval));
Context.RPCClient.Callbacks.PlayerConnect += Callbacks_PlayerConnect;
Context.RPCClient.Callbacks.BeginRace += Callbacks_BeginRace;
Context.RPCClient.Callbacks.EndRace += Callbacks_EndRace;
Context.RPCClient.Callbacks.PlayerFinish += Callbacks_PlayerFinish;
}
void Update()
{
// Check if we can start playing.
if (CanPlay())
{
// Update the time spent and display on the HUD.
timeSpent += Time.deltaTime;
// Update player rank.
rank = LevelManager.Instance.GetRank(timeSpent, score);
UIManager.Instance.UpdateHUD(score, timeSpent, rank);
}
}
private void PlayerListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (PlayerListBox.SelectedItem == null)
{
return;
}
LoadPlayerStack.Visibility = Visibility.Collapsed;
_player = new PlayerData(_hearthstoneData,PlayerListBox.SelectedItem as Player);
PlayerNameLabel.Content = _player.Player.Name;
PlayerRank angryChicken = new PlayerRank();
angryChicken.ID = _hearthstoneData.NextPlayerRankID;
angryChicken.Player = _player.Player;
angryChicken.Season = _player.CurrentSeason;
angryChicken.Rank = _hearthstoneData.Ranks.First(r => r.Name.ToLower() == "angry chicken");
angryChicken.Rank.Stars = 1;
angryChicken.DateAchieved = _player.CurrentSeason.Start;
if (!(_player.PlayerRanks.Any(p => p.Season.ID == _player.CurrentSeason.ID)))
{
_hearthstoneData.AddPlayerRank(angryChicken);
}
PlayerRank currentRank = _player.PlayerRanks.First(d => d.ID == _player.PlayerRanks.Max(p => p.ID));
if (_player.CurrentSeason.ID == currentRank.ID)
{
PlayerCurrenkRankLabel.Content = currentRank.Rank.Name + " (" + currentRank.Rank.Stars + " stars)";
}
else
{
PlayerCurrenkRankLabel.Content = "The Angry Chicken (1 Star)";
}
string classLevels = "Name\t\tLevel";
foreach (HeroClass heroClass in _player.Player.HeroLevels.Keys.OrderBy(c => c.ClassName))
{
classLevels += "\n" + heroClass.ClassName + "\t\t" + _player.Player.HeroLevels[heroClass];
}
PlayerClassLevelsBlock.TextWrapping = TextWrapping.WrapWithOverflow;
PlayerClassLevelsBlock.Text = classLevels;
PlayerDataStack.Visibility = Visibility.Visible;
}
/// <summary>
/// Updates HUD rank text.
/// </summary>
/// <param name="rank">Rank.</param>
void ShowRank(PlayerRank rank)
{
string rankKey = "Rank " + rank.ToString();
rankText.text = string.Format(LocalizationManager.Instance.GetString("HUD Rank"), LocalizationManager.Instance.GetString(rankKey));
}
/// <summary>
/// Updates the HUD.
/// </summary>
/// <param name="time">Time spent.</param>
/// <param name="rank">Rank.</param>
/// <param name="count">Count.</param>
/// <param name="stage">Stage.</param>
public void UpdateHUD(float time, PlayerRank rank, int count, GameplayStage stage)
{
ShowTimer(time);
ShowRank(rank);
ShowCount(count, stage);
}
private void ComputePlayersRanking(object sender, RoutedEventArgs e)
{
SortedList<DateTime, Match> orderedMatchs = new SortedList<DateTime, Match>();
foreach (Match m in Model.Matchs)
{
if (m.LastQueryTimestamp > 0)
{
DateTime matchDate = DateTime.Parse(m.JSonObject.GAMETIMESTAMP, new CultureInfo("en-US", false));
matchDate = ShiftDateIfSameDate(orderedMatchs, matchDate);
orderedMatchs.Add(matchDate, m);
}
}
Dictionary<string, PlayerRank> pr = new Dictionary<string,PlayerRank>();
foreach(var match in orderedMatchs.Values)
{
foreach (var pBlueResult in match.JSonObject.BLUESCOREBOARD)
{
PlayerRank pBlue;
if (!pr.TryGetValue(pBlueResult.PLAYERNICK, out pBlue))
{
pBlue = new PlayerRank(pBlueResult.PLAYERNICK);
pr.Add(pBlueResult.PLAYERNICK, pBlue);
}
foreach (var pRedResult in match.JSonObject.REDSCOREBOARD)
{
PlayerRank pRed;
if (!pr.TryGetValue(pRedResult.PLAYERNICK, out pRed))
{
pRed = new PlayerRank(pRedResult.PLAYERNICK);
pr.Add(pRedResult.PLAYERNICK, pRed);
}
Fight(pBlue, pBlueResult, pRed, pRedResult);
}
}
}
var ordered = pr.OrderBy(kv => -kv.Value.Elo.Rating);
}
internal bool UpdatePlayerRank(PlayerRank playerRank)
{
return AddPlayerRank(playerRank);
}
public bool DeletePlayerRank(PlayerRank playerRank)
{
return _fileData.RemovePlayerRank(playerRank);
}
public bool AddPlayerRank(PlayerRank playerRank)
{
return _fileData.AddPlayerRank(playerRank);
}
private void Fight(PlayerRank p1, Scoreboard player1Result, PlayerRank p2, Scoreboard player2Result)
{
var time1 = Convert.ToDouble(player1Result.PLAYTIME);
var time2 = Convert.ToDouble(player2Result.PLAYTIME);
if (time1 < 300 || time2 < 300)
return;
double p1Dmg = Convert.ToDouble(player1Result.DAMAGEDEALT) / time1 * Convert.ToDouble(player1Result.ACCURACY);
double p2Dmg = Convert.ToDouble(player2Result.DAMAGEDEALT) / time2 * Convert.ToDouble(player2Result.ACCURACY);
if (p1Dmg > p2Dmg)
p1.Elo.Victory(p2.Elo);
else if (p1Dmg == p2Dmg)
p1.Elo.Null(p2.Elo);
else if (p1Dmg < p2Dmg)
p1.Elo.Defeat(p2.Elo);
}
public bool UpdatePlayerRank(PlayerRank playerRank)
{
return _fileData.UpdatePlayerRank(playerRank);
}
internal bool RemovePlayerRank(PlayerRank playerRank)
{
if (AllPlayerRanks.Contains(playerRank))
{
AllPlayerRanks.Remove(playerRank);
return RemovePlayerRank(playerRank);
}
return true;
}
private void LoadPlayerRanks()
{
if (!File.Exists(_playerRankPath))
{
throw new ArgumentException("Player Rank File does not exist.");
}
using (StreamReader playerRankFile = new StreamReader(_playerRankPath))
{
string playerRankLine;
while ((playerRankLine = playerRankFile.ReadLine()) != null)
{
if (playerRankLine.StartsWith("#") || String.IsNullOrWhiteSpace(playerRankLine))
{
continue;
}
string[] playerRankData = playerRankLine.Split('\t');
if (playerRankData.Length >= 6)
{
PlayerRank playerRank = new PlayerRank();
playerRank.ID = int.Parse(playerRankData[0]);
playerRank.Player = Players.First(p => p.ID == int.Parse(playerRankData[1]));
playerRank.Season = Seasons.First(s => s.ID == int.Parse(playerRankData[2]));
playerRank.Rank = AllRanks.First(r => r.ID == int.Parse(playerRankData[3]));
playerRank.Rank.Stars = int.Parse(playerRankData[4]);
playerRank.DateAchieved = DateTime.Parse(playerRankData[5]);
AllPlayerRanks.Add(playerRank);
}
}
}
}
/// <summary>
/// Call this function when the player collects a pickup.
/// </summary>
public void OnPickup()
{
++score;
rank = LevelManager.Instance.GetRank(timeSpent, score);
UIManager.Instance.UpdateHUD(score, timeSpent, rank);
}
void Update()
{
// Check if we can start playing.
if (CanPlay())
{
// Update the time spent and display on the HUD.
timeSpent += Time.deltaTime;
// Update player rank.
rank = LevelManager.Instance.GetRank(timeSpent, score);
UIManager.Instance.UpdateHUD(score, timeSpent, rank);
}
}
internal bool AddPlayerRank(PlayerRank playerRank)
{
if (!RemovePlayerRank(playerRank))
{
return false;
}
AllPlayerRanks.Add(playerRank);
using (StreamWriter playerRankFile = new StreamWriter(_playerRankPath,false))
{
playerRankFile.WriteLine("#Player Ranks");
playerRankFile.WriteLine("#ID\tPlayerID\tSeasonID\tRankID\tStars\tDateAchieved");
foreach (PlayerRank thisPlayerRank in AllPlayerRanks.OrderBy(p => p.ID))
{
playerRankFile.WriteLine(thisPlayerRank.ToString());
}
playerRankFile.Flush();
}
return true;
}
