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); }
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; }