public bool CheckResult(string _player, PlayerResult _result)
{
var _valid = true;
var _playerInfo = Global.Player()[_player];
var _statistic = Game.Statistic[_player];
if (_statistic.weaponPickUp != _result.weaponPickUp)
{
Debug.LogError(_playerInfo.name + ": WeaponPickup does not match.");
_valid = false;
}
if (_statistic.kill != _result.kill)
{
Debug.LogError(_playerInfo.name + ": Kill does not match.");
_valid = false;
}
if (_statistic.death != _result.death)
{
Debug.LogError(_playerInfo.name + ": Death does not match.");
_valid = false;
}
_statistic.CalculateScore();
if (_statistic.score != _result.score)
{
Debug.LogError(_playerInfo.name + ": Score does not match.");
_valid = false;
}
return(_valid);
}
public static object Deserialize(BitStream stream, params object[] args)
{
PlayerResult r = new PlayerResult();
r.Read(stream);
return(r);
}
public void GameOverResponse(SocketIO.SocketIOEvent E)
{
PlayerResult rr = JsonConvert.DeserializeObject <PlayerResult>(E.data.ToString());
gameOver.SetActive(true);
gameOver.transform.GetChild(1).GetComponent <Text>().text = rr.Player.Name + " wins";
}
void Add(string _player, PlayerResult _result)
{
if (m_Entities.ContainsKey(_player))
{
Debug.LogWarning("Trying to add already existing player " + _player + ".");
return;
}
var _obj = (GameObject)Instantiate(entityPrf);
_obj.transform.parent = grid.transform;
_obj.transform.localPosition = Vector3.zero;
_obj.transform.localScale = Vector3.one;
var _entity = _obj.GetComponent <HUDResultBoardEntity>();
m_Entities[_player] = _entity;
_entity.player = _player;
_entity.player = _player;
_entity.character = Global.Player()[_player].characterSelected;
_entity.weaponPickUp = _result.weaponPickUp;
_entity.kill = _result.kill;
_entity.death = _result.death;
_entity.score = _result.score;
}
public void Init(int userID)
{
playerList = new List <PlayerResult>();
for (int i = 0; i < GlobalDataScript.Instance.playerInfos.Count; i++)
{
if (GlobalDataScript.Instance.playerInfos[i].userID == userID)
{
CancelRequestName.text = GlobalDataScript.Instance.playerInfos[i].name;
}
else
{
if (playerList.Count <= 0)
{
PlayerResult pr = player.GetComponent <PlayerResult>();
playerList.Add(pr);
pr.setInitVal(GlobalDataScript.Instance.playerInfos[i]);
}
else
{
GameObject go = Instantiate(player);
go.transform.SetParent(player.transform.parent);
go.transform.localScale = Vector3.one;
PlayerResult pr = go.GetComponent <PlayerResult>();
playerList.Add(pr);
pr.setInitVal(GlobalDataScript.Instance.playerInfos[i]);
}
}
if (GlobalDataScript.Instance.myGameRoomInfo.userID == userID)
{
butSure.gameObject.SetActive(false);
butCancel.gameObject.SetActive(false);
}
}
}
public bool CheckResult(string _player, PlayerResult _result)
{
var _valid = true;
var _playerInfo = Global.Player()[_player];
var _statistic = Game.Statistic[_player];
if (_statistic.weaponPickUp != _result.weaponPickUp)
{
Debug.LogError(_playerInfo.name + ": WeaponPickup does not match.");
_valid = false;
}
if (_statistic.kill != _result.kill)
{
Debug.LogError(_playerInfo.name + ": Kill does not match.");
_valid = false;
}
if (_statistic.death != _result.death)
{
Debug.LogError(_playerInfo.name + ": Death does not match.");
_valid = false;
}
_statistic.CalculateScore();
if (_statistic.score != _result.score)
{
Debug.LogError(_playerInfo.name + ": Score does not match.");
_valid = false;
}
return _valid;
}
void Add(string _player, PlayerResult _result)
{
if (m_Entities.ContainsKey(_player))
{
Debug.LogWarning("Trying to add already existing player " + _player + ".");
return;
}
var _obj = Object.Instantiate(entityPrf, Vector3.zero, Quaternion.identity) as GameObject;
var _scale = _obj.transform.localScale;
_obj.transform.parent = transform;
_obj.transform.localPosition = Vector3.zero;
_obj.transform.localScale = _scale;
var _entity = _obj.GetComponent <HUDResultBoardEntity>();
m_Entities[_player] = _entity;
_entity.player = _player;
_entity.player = _player;
_entity.weaponPickUp = _result.weaponPickUp;
_entity.kill = _result.kill;
_entity.death = _result.death;
_entity.score = _result.score;
}
public PlayerResult Get(int id)
{
var dataCache = new DataCache();
var player = PlayersService.GetInstance().GetPlayer(id, dataCache);
var sports = SportsService.GetInstance().GetSports();
var leagues = LeaguesService.GetInstance().GetLeagues();
var stats = StatsService.GetInstance().GetAllStats(playerID: id, dataCache: dataCache);
var statTypes = GamesService.GetInstance().GetStatTypes().OrderBy(s => s.GridDisplayOrder);
var playerResult = new PlayerResult()
{
ID = player.ID,
Name = player.Name,
Games = player.Games?.Select(g => new PlayerGameResult()
{
ID = g.ID,
GameDate = g.GameDate,
Team1Score = g.Team1Score,
Team2Score = g.Team2Score
}).ToList(),
Teams = player.Teams?.Select(t =>
{
var league = leagues.First(l => l.ID == t.LeagueID);
var sport = sports.First(s => s.ID == league.SportID);
return(new PlayerTeamResult()
{
ID = t.ID,
Name = t.Name,
LeagueID = t.LeagueID,
Number = t.PlayerNumber,
SportID = league.SportID,
LeagueName = string.Format("{0} - {1} {2} - {3}", sport.Name, league.StartDate.Year, league.Season.ToString(), league.Name)
});
}).OrderBy(t => t.LeagueName).ToList(),
HockeyStats = stats
.Select(s => ConvertObjects.ConvertType(s))
.Where(s => s.Sport == SportsList.Hockey && leagues.Exists(l => l.ID == s.LeagueID))
.OrderBy(s => leagues.First(l => l.ID == s.LeagueID).StartDate)
.ToList(),
BaseballStats = stats
.Select(s => ConvertObjects.ConvertType(s))
.Where(s => s.Sport == SportsList.Baseball && leagues.Exists(l => l.ID == s.LeagueID))
.OrderBy(s => leagues.First(l => l.ID == s.LeagueID).StartDate)
.ToList(),
BasketballStats = stats
.Select(s => ConvertObjects.ConvertType(s))
.Where(s => s.Sport == SportsList.Basketball && leagues.Exists(l => l.ID == s.LeagueID))
.OrderBy(s => leagues.First(l => l.ID == s.LeagueID).StartDate)
.ToList(),
HockeyStatTypes = statTypes.Select(s => ConvertObjects.ConvertType(s)).Where(st => st.Sport == SportsList.Hockey).ToList(),
BaseballStatTypes = statTypes.Select(s => ConvertObjects.ConvertType(s)).Where(st => st.Sport == SportsList.Baseball).ToList(),
BasketballStatTypes = statTypes.Select(s => ConvertObjects.ConvertType(s)).Where(st => st.Sport == SportsList.Basketball).ToList(),
};
UpdateStatRow(playerResult.HockeyStats, player, leagues);
UpdateStatRow(playerResult.BaseballStats, player, leagues);
UpdateStatRow(playerResult.BasketballStats, player, leagues);
return(playerResult);
}
public static PlayerResult calculateResults(int totalTeamPrize, int perPlaceGoldStep, int goldForUnfinished)
{
//Rpc can't send list of objects :(
PlayerResult result = new PlayerResult();
int totalSize = allFinishedPlayers.Count + allActivePlayers.Count;
result.allPlayerNetIds = new NetworkInstanceId[totalSize];
result.allPlaces = new int[totalSize];
result.allGoldWon = new int[totalSize];
//determine winning team
//It is the team, which has the most finished players. If equal #, winning is the team with max finished and 1st player among finished
int winningTeamId = determineWinningTeam();
int nOfWinningTeam = 0;
foreach (Player p in allFinishedPlayers)
{
if (p.getTeamId() == winningTeamId)
{
nOfWinningTeam++;
}
}
int goldPerPersonInTeam = (int)Mathf.Floor(totalTeamPrize / nOfWinningTeam);
int totalPlayersFinished = allFinishedPlayers.Count;
int i = 0;
int goldWon = 0;
foreach (Player p in allFinishedPlayers)
{
result.allPlayerNetIds[i] = p.netId;
result.allPlaces[i] = i + 1;
goldWon = (totalPlayersFinished - i) * perPlaceGoldStep;
if (p.getTeamId() == winningTeamId)
{
goldWon += goldPerPersonInTeam;
}
result.allGoldWon[i] = goldWon;
p.gold += goldWon;//[SyncVar]
i++;
}
foreach (Player p in allActivePlayers)
{
result.allPlayerNetIds[i] = p.netId;
result.allPlaces[i] = totalPlayersFinished + 1;
result.allGoldWon[i] = goldForUnfinished;
p.gold += result.allGoldWon[i];//[SyncVar]
i++;
}
return(result);
}
private static double CalcMbq(int discResult, PlayerResult whiteStandings)
{
if (whiteStandings == null)
{
return(discResult);
}
return(discResult + whiteStandings.Score * 6);
}
public static async Task <PlayerResult> GetPlayers(int clubId)
{
PlayerResult playerResult = await Try(
$"PlayerResult-{clubId}.json",
() => Client.GetPlayers(clubId));
return(playerResult);
}
private void SetChallengeStanding(PlayerResult playerResult, Player foundPlayer)
{
var handicap = _dataView.GetPlayerHandicap(foundPlayer);
var fastestLapWithHandicap = playerResult.FastestLap + handicap;
var challengePlayerStanding = new ChallengePlayerStanding(foundPlayer, fastestLapWithHandicap);
_challengeStandings[playerResult.ChallengeId].SetChallengePlayerStanding(challengePlayerStanding);
}
private async Task <IHttpActionResult> Handle(GetPlayersFromBitsMessage message)
{
WebsiteConfig websiteConfig = DocumentSession.Load <WebsiteConfig>(WebsiteConfig.GlobalId);
PlayerResult playersResult = await bitsClient.GetPlayers(websiteConfig.ClubId);
Player[] players = DocumentSession.Query <Player, PlayerSearch>()
.ToArray();
// update existing players by matching on license number
var playersByLicense = playersResult.Data.ToDictionary(x => x.LicNbr);
foreach (Player player in players.Where(x => x.PlayerItem != null))
{
if (playersByLicense.TryGetValue(player.PlayerItem.LicNbr, out PlayerItem playerItem))
{
player.PlayerItem = playerItem;
playersByLicense.Remove(player.PlayerItem.LicNbr);
Log.Info($"Updating player with existing PlayerItem: {player.PlayerItem.LicNbr}");
}
else
{
Log.Info($"Player with {player.PlayerItem.LicNbr} not found from BITS");
}
}
// add missing players, i.e. what is left from first step
// try first to match on name, update those, add the rest
var playerNamesWithoutPlayerItem = players.Where(x => x.PlayerItem == null).ToDictionary(x => x.Name);
foreach (PlayerItem playerItem in playersByLicense.Values)
{
// look for name
string nameFromBits = $"{playerItem.FirstName} {playerItem.SurName}";
if (playerNamesWithoutPlayerItem.TryGetValue(nameFromBits, out Player player))
{
player.PlayerItem = playerItem;
Log.Info($"Updating player with missing PlayerItem: {nameFromBits}");
}
else
{
// create new
var newPlayer = new Player(
$"{playerItem.FirstName} {playerItem.SurName}",
playerItem.Email,
playerItem.Inactive ? Player.Status.Inactive : Player.Status.Active,
playerItem.GetPersonalNumber(),
string.Empty,
new string[0])
{
PlayerItem = playerItem
};
Log.Info($"Created player {playerItem.FirstName} {playerItem.SurName}");
DocumentSession.Store(newPlayer);
}
}
return(Ok());
}
private static PlayerResult CreateNewPlayerResults(Player player, PlayerResult lastStanding, double newScore, double newMbq)
{
return(new PlayerResult()
{
Player = player,
Score = lastStanding != null ? lastStanding.Score + newScore : newScore,
MBQ = lastStanding != null ? lastStanding.MBQ + newMbq : newMbq,
});
}
public bool AddChallengeResult(int playerId, ChallengeResult challengeResult)
{
if (DateTime.Now > CurrentSeason.EndDate)
{
Globals.Logger.Debug(
$"{challengeResult.ToLongString()} was not added because the season is over. Now: {DateTime.Now}, EndDate: {CurrentSeason.EndDate}");
return(false);
}
Challenge foundChallenge = CurrentSeason.Challenges.FirstOrDefault
(
c => c.TrackName == challengeResult.TrackLocationAndVariant &&
c.CarName == challengeResult.CarName
);
if (foundChallenge == null)
{
Globals.Logger.Debug(
$"{challengeResult.ToLongString()} was not added because the challenge wasn't found in the current season {CurrentSeason}.");
return(false);
}
PlayerResult foundPlayerResult = PlayerResults.FirstOrDefault(p => p.ChallengeId == foundChallenge.Id && p.PlayerId == playerId);
if (foundPlayerResult == null)
{
PlayerResults.Add(new PlayerResult
{
PlayerId = playerId,
ChallengeId = foundChallenge.Id,
FastestLap = challengeResult.LastValidLapTime
});
Globals.Logger.Debug(
$"PlayerId: {playerId}, {challengeResult.ToLongString()} was added to DataView.PlayerResults.");
}
else
{
if (challengeResult.LastValidLapTime < foundPlayerResult.FastestLap)
{
foundPlayerResult.FastestLap = challengeResult.LastValidLapTime;
Globals.Logger.Debug(
$"PlayerId: {playerId}, {challengeResult.ToLongString()}. DataView foundPlayerResult was successfully updated.");
}
else
{
Globals.Logger.Debug(
$"PlayerId: {playerId}, {challengeResult.ToLongString()} was not added because it's not a best time. Fastest lap: {foundPlayerResult.FastestLap}, last lap: {challengeResult.LastValidLapTime}.");
return(false);
}
}
return(true);
}
public MatchResultViewModel()
{
PlayerResults = new PlayerResult[22];
for (int i = 0; i < 22; i++)
{
PlayerResults[i] = new PlayerResult();
}
FCP = new FinalClassificationPacketPlus(); // replaced with new packet class
PP = new ParticipantPacket();
}
private PlayerResult SetPlayerSetsResulst(PlayerModel playerModel)
{
var playerOneResult = new PlayerResult
{
FirstSet = playerModel.SetsResult[0],
SecondSet = playerModel.SetsResult[1],
ThirdSet = playerModel.SetsResult[2]
};
return(playerOneResult);
}
private void AddResult(List <PlayerStats> stats, PlayerResult player)
{
var existing = stats.FirstOrDefault(s => s.GolferId == player.Golfer.Id);
if (existing != null)
{
AddToExisting(existing, player);
}
else
{
CreateInitial(stats, player);
}
}
internal static string ConstructInfoString(PlayerResult result)
{
StringBuilder builder = new StringBuilder();
builder = builder.AppendLine("Tag: " + result.tag);
builder = builder.AppendLine("Név: " + result.name);
builder = builder.AppendLine("Clan: " + result.clan.name);
builder = builder.AppendLine("Trófeák: " + result.trophies);
builder = builder.AppendLine("Winek: " + result.wins);
builder = builder.AppendLine("Szint: " + result.expLevel);
return(builder.ToString());
}
private void CreateInitial(List <PlayerStats> stats, PlayerResult player)
{
var playerStats = new PlayerStats();
playerStats.GolferId = player.Golfer.Id;
playerStats.GrossScore = player.Score;
playerStats.Handicap = player.Golfer.LeagueHandicap;
playerStats.LastPoints = player.Points;
playerStats.Name = $"{player.Golfer.FirstName} {player.Golfer.LastName[0]}.";
playerStats.NetScore = player.Score - player.Golfer.LeagueHandicap;
AddToExisting(playerStats, player);
stats.Add(playerStats);
}
public void Add_PlayerResult_For_Player()
{
var hole1score = new HoleScore {
HoleNumber = 1, Score = 3
};
var hole2score = new HoleScore {
HoleNumber = 2, Score = 3
};
var player = new Player
{
FirstName = "Mikael",
LastName = "Edvardsson"
};
var playerResult = new PlayerResult
{
Player = player,
Penalties = 0,
Place = 1
};
playerResult.AddHoleScore(hole1score);
playerResult.AddHoleScore(hole2score);
Player dbPlayer;
PlayerResult dbPlayerResult;
using (var session = NHibernateFactory.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
var pid = session.Save(player);
var prid = session.Save(playerResult);
dbPlayer = session.Get <Player>(pid);
dbPlayerResult = session.Get <PlayerResult>(prid);
session.Delete(dbPlayer);
session.Delete(dbPlayerResult);
transaction.Commit();
}
}
Assert.AreEqual(player, dbPlayer);
Assert.AreEqual(playerResult, dbPlayerResult);
Assert.That(dbPlayerResult.Scores.Count == 2);
}
public static Player ConvertType(PlayerResult o)
{
return(new Player()
{
ID = o.ID,
Name = o.Name,
Teams = o.Teams
.Select(t => new Team()
{
ID = t.ID,
PlayerNumber = t.Number
})
.ToList()
});
}
public async Task <PlayerResult> GetPlayers(int clubId)
{
PlayerResult result = await Post <PlayerResult>(
new
{
ClubId = clubId,
TakeOnlyActive = true,
take = "250",
skip = 0,
page = 1,
pageSize = "250",
sort = new object[0]
},
$"https://api.swebowl.se/api/v1/player/GetAll?APIKey={apiKey}");
return(result);
}
public async Task AddOrUpdate_Update()
{
var prt = new PlayerResultTable(Mock.Of <ILogger <RepositoryTable <PlayerResult, string, Guid> > >(), tableFixture.Repository);
var playerId = Guid.NewGuid();
var result = new PlayerResult(playerId)
{
Name = "dummy", LastMeasurement = DateTime.UtcNow, AvgNumberOfShots = 1d
};
await prt.Add(result);
await prt.AddOrUpdate(playerId, "FooBar", DateTime.UtcNow, 2d, 1d);
Assert.Equal("FooBar", (await prt.GetSingle(playerId)) !.Name);
await prt.Delete(playerId);
}
// Instantiates and populates a line of Leaderboard using a PlayerResult value, and adds it to the List of lines
private void CreateLeaderboardLine(PlayerResult result, Transform table, List <Transform> transformList)
{
float templateHeight = 30f;
Transform lineTransform = Instantiate(leaderboardLine, table);
RectTransform lineRectTransform = lineTransform.GetComponent <RectTransform>();
lineRectTransform.anchoredPosition += new Vector2(0, -templateHeight * transformList.Count);
lineTransform.gameObject.SetActive(true);
// Put player position to line
int place = (transformList.Count + 1);
lineTransform.Find("Place").GetComponent <Text>().text = place.ToString();
// Put player name to line if exists; if not - put "anonymous" name
string name = result.playerName;
if (name == "" || name == null)
{
name = playerInfo.DefaultPlayerName;
}
lineTransform.Find("Name").GetComponent <Text>().text = name;
// Put player result score to line
int score = result.playerScore;
lineTransform.Find("Score").GetComponent <Text>().text = score.ToString();
// Added color differentiation between lines
lineTransform.Find("LineBackground").gameObject.SetActive(place % 2 != 1);
// Bold font to the top-3 positions
if (place == 1 || place == 2 || place == 3)
{
lineTransform.Find("Place").GetComponent <Text>().fontStyle = FontStyle.Bold;
lineTransform.Find("Name").GetComponent <Text>().fontStyle = FontStyle.Bold;
lineTransform.Find("Score").GetComponent <Text>().fontStyle = FontStyle.Bold;
}
transformList.Add(lineTransform);
}
public override async Task Handle(HandlerContext <Command> context)
{
WebsiteConfig websiteConfig = CompositionRoot.DocumentSession.Load <WebsiteConfig>(WebsiteConfig.GlobalId);
PlayerResult playersResult = await CompositionRoot.BitsClient.GetPlayers(websiteConfig.ClubId);
Player[] players = CompositionRoot.DocumentSession.Query <Player, PlayerSearch>()
.ToArray();
// update existing players by matching on license number
Dictionary <string, PlayerItem> playersByLicense = playersResult.Data.ToDictionary(x => x.LicNbr !);
foreach (Player player in players.Where(x => x.PlayerItem != null))
{
if (playersByLicense.TryGetValue(player.PlayerItem !.LicNbr !, out PlayerItem playerItem))
{
player.PlayerItem = playerItem;
_ = playersByLicense.Remove(player.PlayerItem.LicNbr !);
Logger.InfoFormat(
"Updating player with existing PlayerItem {licNbr}",
player.PlayerItem.LicNbr);
}
public void FillIn()
{
if (IsLatest())
{
Debug.LogWarning("Trying to reset again. Ignore.");
return;
}
gameID = Game.Progress().gameID;
results = new Dictionary <string, PlayerResult> ();
foreach (var _player in Global.Player().players)
{
var _result = new PlayerResult();
var _statistic = Game.Statistic().Get(_player.Key);
// _result.kill = ;
_result.death = _statistic.death;
_result.score = _statistic.score;
results.Add(_player.Key, _result);
}
}
public void FillIn()
{
if (IsLatest())
{
Debug.LogWarning("Trying to reset again. Ignore.");
return;
}
gameID = Game.Progress().gameID;
results = new Dictionary<string, PlayerResult> ();
foreach (var _player in Global.Player().players)
{
var _result = new PlayerResult();
var _statistic = Game.Statistic().Get(_player.Key);
// _result.kill = ;
_result.death = _statistic.death;
_result.score = _statistic.score;
results.Add(_player.Key, _result);
}
}
public int CompareTo(object obj)
{
if (obj == null)
{
return(1);
}
PlayerResult otherResult = obj as PlayerResult;
if (otherResult != null)
{
if (score == otherResult.score)
{
return(deaths.CompareTo(otherResult.deaths));
}
return(score.CompareTo(otherResult.score) * -1);
}
else
{
throw new ArgumentException("Object is not a PlayerResult");
}
}
/// <summary>
/// Play the game with the specified number of players.
/// </summary>
/// <param name="playerCount">
/// The number of players.
/// </param>
/// <returns>
/// The result of playing the game.
/// </returns>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if the number of players is out of range.
/// </exception>
public GameResult PlayGame(int playerCount)
{
var deck = _drawingService.DrawDeck();
var maxPlayerCount = (deck.Count - 1) / PlayerHandSize;
if (playerCount < MinPlayerCount || playerCount > maxPlayerCount)
{
throw new ArgumentOutOfRangeException(nameof(playerCount), playerCount,
$"Player count must be between {MinPlayerCount} and {maxPlayerCount}.");
}
var wildcard = _drawingService.DrawCard(deck);
var results = new PlayerResult[playerCount];
for (var playerIndex = 0; playerIndex < playerCount; playerIndex++)
{
var cards = _drawingService.DrawHand(deck, PlayerHandSize);
var scoredCards = _scoringService.GetScoredCards(cards, wildcard).ToArray();
results[playerIndex] = new PlayerResult
{
Player = playerIndex + 1,
Cards = scoredCards,
Points = scoredCards.Sum(c => c.Points),
};
}
var gameResult = new GameResult()
{
Wildcard = wildcard,
PlayerResults = results
.OrderByDescending(r => r.Points)
.ThenBy(r => r.Player)
.ToArray()
};
return(gameResult);
}
public static IEnumerator finishLevel()
{
yield return(new WaitForSeconds(1f));//make a little pause between player finishing and displaying results
if (isCurrentSceneShop == false)
{
string sceneName = SceneManager.GetActiveScene().name;
int totalTeamPrize = 0;
int perPlaceGoldStep = 0;
int goldForUnfinished = 0;
if (sceneName == "level1")
{
totalTeamPrize = 400;
perPlaceGoldStep = 10;
goldForUnfinished = 5;
}
else if (sceneName == "level2")
{
totalTeamPrize = 500;
perPlaceGoldStep = 50;
goldForUnfinished = 25;
}
//calculate scores
PlayerResult result = AllPlayerManager.calculateResults(totalTeamPrize, perPlaceGoldStep, goldForUnfinished);
//deactivate remaining players
AllPlayerManager.finishRemainingPlayers();
allGMInst.RpcDisplayLevelResults(result.allPlaces, result.allPlayerNetIds, result.allGoldWon);
instanceSelf.InvokeRepeating("reduceTimeUntilNextLevel", 1, 1f);
}
else
{
serverChangeScene();
}
}
public void AddScoreToFile()
{
LoadScoreList();
PlayerResult pRes = new PlayerResult();
pRes.pScore = scoreObj.GetComponent <ScoreScript>().GetScore();
pRes.pName = inputField.GetComponent <TMPro.TextMeshProUGUI>().text;
Debug.Log(pRes.pScore + " " + pRes.pName);
if (playerResList.playerScoreList.Count > 9)
{
for (int i = 0; i < playerResList.playerScoreList.Count; i++)
{
if (pRes.pScore > playerResList.playerScoreList[i].pScore)
{
int minscore = 13 * 11;
int minIndex = -1;
for (int j = 0; j < playerResList.playerScoreList.Count; j++)
{
if (minscore > playerResList.playerScoreList[i].pScore)
{
minscore = playerResList.playerScoreList[i].pScore;
minIndex = j;
}
}
playerResList.playerScoreList[minIndex] = pRes;
break;
}
}
}
else
{
playerResList.playerScoreList.Add(pRes);
}
var jsonRes = JsonUtility.ToJson(playerResList);
PlayerPrefs.SetString("PlayerScore", jsonRes);
}
void Add(string _player, PlayerResult _result)
{
if (m_Entities.ContainsKey(_player))
{
Debug.LogWarning("Trying to add already existing player " + _player + ".");
return;
}
var _obj = (GameObject) Instantiate(entityPrf);
_obj.transform.parent = grid.transform;
_obj.transform.localPosition = Vector3.zero;
_obj.transform.localScale = Vector3.one;
var _entity = _obj.GetComponent<HUDResultBoardEntity>();
m_Entities[_player] = _entity;
_entity.player = _player;
_entity.player = _player;
_entity.character = Global.Player()[_player].characterSelected;
_entity.weaponPickUp = _result.weaponPickUp;
_entity.kill = _result.kill;
_entity.death = _result.death;
_entity.score = _result.score;
}
void Add(string _player, PlayerResult _result)
{
if (m_Entities.ContainsKey(_player))
{
Debug.LogWarning("Trying to add already existing player " + _player + ".");
return;
}
var _obj = Object.Instantiate(entityPrf, Vector3.zero, Quaternion.identity) as GameObject;
var _scale = _obj.transform.localScale;
_obj.transform.parent = transform;
_obj.transform.localPosition = Vector3.zero;
_obj.transform.localScale = _scale;
var _entity = _obj.GetComponent<HUDResultBoardEntity>();
m_Entities[_player] = _entity;
_entity.player = _player;
_entity.player = _player;
_entity.weaponPickUp = _result.weaponPickUp;
_entity.kill = _result.kill;
_entity.death = _result.death;
_entity.score = _result.score;
}
/// <summary>
/// Method makes a player win his/her stake and win the game
/// </summary>
public void WinStake()
{
Money += Stake;
PlayResult = PlayerResult.WIN;
}
public void FillIn()
{
if (isLatest)
{
Debug.LogWarning("Trying to fill in again. Ignore.");
return;
}
m_IsLatest = true;
results = new Dictionary<string, PlayerResult> ();
foreach (var _player in Global.Player().players)
{
var _result = new PlayerResult();
var _statistic = Game.Statistic[_player.Key];
_result.kill = _statistic.kill;
_result.death = _statistic.death;
_result.weaponPickUp = _statistic.weaponPickUp;
_statistic.CalculateScore();
_result.score = _statistic.score;
results.Add(_player.Key, _result);
}
}
private PlayerResult loadLine(string line)
{
Contract.Requires<ArgumentNullException>(line != null);
List<string> columns = new List<string>(line.Split(','));
if (columns.Count == 0) {
return null;
}
PlayerResult player = null;
switch (columns[0]) {
case "UN":
if (loadingPlayer != null) {
player = loadingPlayer;
}
loadingPlayer = new PlayerResult();
int id;
int.TryParse(columns[1], out id);
loadingPlayer.ID = id;
break;
case "EF":
if (loadingPlayer != null) {
player = loadingPlayer;
}
loadingPlayer = null;
break;
case "NA":
loadingPlayer.Name = columns[1];
break;
case "UT":
Team team;
Enum.TryParse<Team>(columns[1], out team);
loadingPlayer.Team = team;
break;
case "LI":
loadingPlayer.Leave = columns[1].Equals("2");
break;
case "JT":
int joinTime;
int.TryParse(columns[1], out joinTime);
loadingPlayer.JoinTime = joinTime;
break;
case "LT":
int leaveTime;
int.TryParse(columns[1], out leaveTime);
loadingPlayer.LeaveTime = leaveTime;
break;
case "SH":
Contract.Assume(loadingPlayer != null);
loadingPlayer.ShotTimes = parseIntegerColumns(columns);
break;
case "HI":
Contract.Assume(loadingPlayer != null);
loadingPlayer.HitTimes = parseIntegerColumns(columns);
break;
case "KI":
Contract.Assume(loadingPlayer != null);
loadingPlayer.KillTimes = parseIntegerColumns(columns);
break;
case "DI":
Contract.Assume(loadingPlayer != null);
loadingPlayer.DieTimes = parseIntegerColumns(columns);
break;
case "SU":
Contract.Assume(loadingPlayer != null);
loadingPlayer.SuicideTimes = parseIntegerColumns(columns);
break;
case "SA":
Contract.Assume(loadingPlayer != null);
loadingPlayer.SaveTimes = parseIntegerColumns(columns);
break;
case "TR":
Contract.Assume(loadingPlayer != null);
loadingPlayer.TryTimes = parseIntegerColumns(columns);
break;
case "HO":
Contract.Assume(loadingPlayer != null);
loadingPlayer.HomeTimes = parseIntegerColumns(columns);
break;
default:
break;
}
return player;
}
/// <summary>
/// Method makes a player lose his/her stake and lose the game
/// </summary>
public void LoseStake()
{
Money -= Stake;
PlayResult = PlayerResult.LOSE;
}
public void SortPlayers()
{
PlayerResult player1Result = new PlayerResult(1,gameInfo.player1score, gameInfo.player1deaths);
PlayerResult player2Result = new PlayerResult(2,gameInfo.player2score, gameInfo.player2deaths);
PlayerResult player3Result = new PlayerResult(3,gameInfo.player3score, gameInfo.player3deaths);
PlayerResult player4Result = new PlayerResult(4,gameInfo.player4score, gameInfo.player4deaths);
playersOrder = new List<PlayerResult>();
playersOrder.Add(player1Result);
playersOrder.Add(player2Result);
playersOrder.Add(player3Result);
playersOrder.Add(player4Result);
playersOrder.Sort();
switch (playersOrder[0].playerNumber)
{
case 1:
firstPlace = player1;
break;
case 2:
firstPlace = player2;
break;
case 3:
firstPlace = player3;
break;
case 4:
firstPlace = player4;
break;
}
switch (playersOrder[1].playerNumber)
{
case 1:
secondPlace = player1;
break;
case 2:
secondPlace = player2;
break;
case 3:
secondPlace = player3;
break;
case 4:
secondPlace = player4;
break;
}
switch (playersOrder[2].playerNumber)
{
case 1:
thirdPlace = player1;
break;
case 2:
thirdPlace = player2;
break;
case 3:
thirdPlace = player3;
break;
case 4:
thirdPlace = player4;
break;
}
switch (playersOrder[3].playerNumber)
{
case 1:
fourthPlace = player1;
break;
case 2:
fourthPlace = player2;
break;
case 3:
fourthPlace = player3;
break;
case 4:
fourthPlace = player4;
break;
}
}
