private Player PopTournamentPlayer(TournamentPlayer _TournamentPlayer, Vector3 _Position, int _Index)
{
GameObject playerGo = null;
Player player = null;
playerGo = Instantiate((_TournamentPlayer.m_Human == true) ? m_HumanPlayer : m_IAPlayer, _Position, Quaternion.identity) as GameObject;
player = playerGo.GetComponent <Player>();
#if UNITY_EDITOR
Debug.Log("m_PlayerSkinID : " + m_PlayerSkinID);
Debug.Log("Human : " + _TournamentPlayer.m_Human);
#endif
_TournamentPlayer.m_ColorIndex = _Index;
player.Init(_TournamentPlayer.m_PlayerName, m_Brushs[_TournamentPlayer.m_BrushIndex], m_Colors[_Index]);
if (_TournamentPlayer.m_Human)
{
m_HumanPlayerTr = player.transform;
m_BattleRoyaleManager.SetHumanPlayer(player);
}
if (onPlayerSpawned != null)
{
onPlayerSpawned.Invoke(player, _Index);
}
return(player);
}
public async Task <Participant <Player> > AddPlayerToTournamentAsync(string tournamentId, Participant <Player> player)
{
var playerRef = new TournamentPlayer()
{
Player = new SanityReference <Player>()
{
Ref = player.Item.Id,
SanityKey = player.Item.Id,
},
Information = player.Information.ToList(),
ToornamentId = player.ToornamentId,
};
SanityTournament tournament = await Sanity.DocumentSet <SanityTournament>().GetAsync(tournamentId);
if (tournament == null || tournament.SignupType == "team" || !tournament.RegistrationOpen)
{
return(null);
}
if (tournament.SoloPlayers == null)
{
tournament.SoloPlayers = new List <TournamentPlayer>();
}
if (tournament.SoloPlayers.Find(t => t.Player.Ref == player.Item.Id) != null)
{
return(null);
}
tournament.SoloPlayers.Add(playerRef);
await Sanity.DocumentSet <SanityTournament>().Update(tournament).CommitAsync();
return(player);
}
private void CreateOrUpdatePlayer(object sender, RoutedEventArgs e)
{
try
{
Tournament tournament = (Tournament)this.DataContext;
var item = TournamentPlayers.DataContext as TournamentPlayer;
if (item.Id != 0)
{
db.SaveChanges();
NewPlayer(tournament.Id);
refreshTable();
}
else
{
int playerId = ((Player)cmbPlayers.SelectedItem).Id;
bool alreadyInGame = false;
if (tournament.TournamentPlayers != null)
{
alreadyInGame = tournament.TournamentPlayers.Any(x => x.PlayerId == playerId);
}
if (tournament.Id != 0 && !alreadyInGame)
{
TournamentPlayer gameplayer = (TournamentPlayer)TournamentPlayers.DataContext;
gameplayer.PlayerId = playerId;
db.TournamentPlayers.Add(gameplayer);
db.SaveChanges();
NewPlayer(tournament.Id);
refreshTable();
}
}
}
catch (Exception ex) { }
}
public async Task <IActionResult> PutTournamentPlayer([FromRoute] int id, [FromBody] TournamentPlayer tournamentPlayer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != tournamentPlayer.TournamentPlayerID)
{
return(BadRequest());
}
_context.Entry(tournamentPlayer).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TournamentPlayerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Create_ShouldHaveNonNullSCoreObject()
{
var comms = Substitute.For <IPlayerCommunicationChannel>();
var tp = new TournamentPlayer(null, null);
Assert.That(tp.Score, Is.Not.Null);
}
public void AddTournamentPlayer(TournamentPlayer player)
{
DateTime now = DateTime.Now;
player.Id = Guid.NewGuid();
player.Created = now;
player.Updated = now;
mConnection.Execute("INSERT INTO TournamentsPlayers(id,created,updated,tournamentid,playerid,teamid)" +
"values(@id,@created,@updated,@tournamentid,@playerid,@teamid)", player);
}
public async Task <IActionResult> PostTournamentPlayer([FromBody] TournamentPlayer tournamentPlayer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.TournamentPlayer.Add(tournamentPlayer);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTournamentPlayer", new { id = tournamentPlayer.TournamentPlayerID }, tournamentPlayer));
}
public void RegisterPlayer(int tournamentId, int playerId)
{
var tournament = _repository.FindById(tournamentId);
if (!tournament.TournamentPlayers.Any(tp => tp.PlayerId == playerId))
{
var tournamentPlayer = new TournamentPlayer {
PlayerId = playerId
};
tournament.TournamentPlayers.Add(tournamentPlayer);
_repository.Update(tournament);
}
}
public void CanRegisterPlayers_AndRetrieveTheirDetailsLater()
{
var playerOneName = "Alex";
var playerOneId = Guid.NewGuid().ToString();
var playerOne = new TournamentPlayer(playerOneId, playerOneName);
playerOne.Comms = Substitute.For <IPlayerCommunicationChannel>();
_tournament.RegisterPlayer(playerOne);
Assert.That(_tournament.Players.Count(), Is.EqualTo(1));
Assert.That(_tournament.Players.First().Id, Is.EqualTo(playerOneId));
Assert.That(_tournament.Players.First().Name, Is.EqualTo(playerOneName));
}
public void Read2(string file)
{
string line = null;
using (StreamReader reader = new StreamReader(@file))
{
while ((line = reader.ReadLine()) != null)
{
string[] values = line.Split(' ');
TournamentPlayer tournamentPlayer = new TournamentPlayer(long.Parse(values[0]), long.Parse(values[1]), double.Parse(values[2]));
_context.TournamentPlayers.Add(tournamentPlayer);
_context.SaveChanges();
}
}
}
public ActionResult <string> RegisterForTournament([FromBody] Dictionary <string, string> dict)
{
try
{
int userId;
Int32.TryParse(dict["UserId"], out userId);
int tournamentId;
Int32.TryParse(dict["TournamentId"], out tournamentId);
Tournament tournament = unitOfWork.TournamentRepository.GetByID(tournamentId);
TournamentPlayer newRegister = new TournamentPlayer()
{
TournamentId = tournament.TournamentId,
UserId = userId
};
List <TournamentPlayer> tournamentPlayerList = new List <TournamentPlayer>();
//Checks if player already registred or not
foreach (var item in unitOfWork.TournamentPlayerRepository.Get())
{
if (item.TournamentId == tournamentId && item.UserId == userId)
{
return(StatusCode(500, "Something went wrong!"));
}
}
if (tournament.CurrentPlayers < tournament.MaxPlayer)
{
unitOfWork.TournamentPlayerRepository.Insert(newRegister);
tournament.CurrentPlayers += 1;
if (tournament.CurrentPlayers == tournament.MaxPlayer)
{
StartTournament(tournament.TournamentId);
}
}
unitOfWork.TournamentRepository.Update(tournament);
unitOfWork.Save();
return(StatusCode(200, "OK"));
}
catch (Exception)
{
return(StatusCode(500, "Something went wrong!"));
}
}
public ViewModel(IEnumerable <TournamentPlayer> players, int roundsLeft, List <CardInfo> humanLibrary)
{
_humanLibrary = humanLibrary;
RoundsLeft = roundsLeft;
var matchesPlayed = players.Max(x => x.MatchesPlayed);
_playerCount = players.Count();
var finished = players
.Where(x => x.MatchesPlayed == matchesPlayed)
.ToList();
_finishedPlayers = new List <TournamentPlayer>(finished);
_finishedPlayers.Sort();
_humanPlayer = players.First(x => x.IsHuman);
}
public void GivenTheSamePlayerIdIsRegisteredMultipleTimes_ThenTheNameIsUpdated()
{
var playerOneName = "Alex";
var playerOneId = Guid.NewGuid().ToString();
var playerOne = new TournamentPlayer(playerOneId, playerOneName);
playerOne.Comms = Substitute.For <IPlayerCommunicationChannel>();
_tournament.RegisterPlayer(playerOne);
var playerOneSecondTime = new TournamentPlayer(playerOneId, "Bob");
playerOneSecondTime.Comms = Substitute.For <IPlayerCommunicationChannel>();
_tournament.RegisterPlayer(playerOneSecondTime);
Assert.That(_tournament.Players.Count(), Is.EqualTo(1));
Assert.That(_tournament.Players.First().Name, Is.EqualTo("Bob"));
}
public void GetFinishedGamesWithEnemies()
{
var playerX = new TournamentPlayer {
Name = "x", Version = 1
};
var playerY = new TournamentPlayer {
Name = "y", Version = 1
};
var games = new List <BattleResult>
{
new BattleResult
{
Player1Result = new BattlePlayerResult {
Player = playerX, ResultType = BattlePlayerResultType.Win, StartAddress = 1
},
Player2Result = new BattlePlayerResult {
Player = playerY, ResultType = BattlePlayerResultType.Loss, StartAddress = 2
},
},
new BattleResult
{
Player1Result = new BattlePlayerResult {
Player = playerY, ResultType = BattlePlayerResultType.Loss, StartAddress = 2
},
Player2Result = new BattlePlayerResult {
Player = playerX, ResultType = BattlePlayerResultType.Win, StartAddress = 1
},
},
};
var xStat = ArenaPlayerHandler.GetFinishedGamesWithEnemies(games, "x", 1, true)[0];
Console.Out.WriteLine(xStat);
Assert.That(xStat.Wins, Is.EqualTo(2));
Assert.That(xStat.Loses, Is.EqualTo(0));
Assert.That(xStat.Draws, Is.EqualTo(0));
Assert.That(xStat.GameInfos[0].Label, Is.EqualTo("Win"));
Assert.That(xStat.GameInfos[0].Player1Result.Player.Name, Is.EqualTo("x"));
Assert.That(xStat.GameInfos[0].Player1Result.ResultType, Is.EqualTo(BattlePlayerResultType.Win));
Assert.That(xStat.GameInfos[0].Player1Result.StartAddress, Is.EqualTo(1));
Assert.That(xStat.GameInfos[1].Label, Is.EqualTo("Win"));
Assert.That(xStat.GameInfos[1].Player1Result.Player.Name, Is.EqualTo("y"));
Assert.That(xStat.GameInfos[1].Player1Result.ResultType, Is.EqualTo(BattlePlayerResultType.Loss));
Assert.That(xStat.GameInfos[1].Player1Result.StartAddress, Is.EqualTo(2));
}
private static void RegisterPlayers()
{
ConsoleUi.WriteTextLine("Register players!" + Environment.NewLine);
bool registerMore = true;
while (registerMore)
{
ConsoleUi.WriteTextLine("Please enter player name: ");
var name = ConsoleUi.ReadText();
var id = Guid.NewGuid().ToString();
var player = new TournamentPlayer(id, name);
var consoleCommChannel = new ConsoleCommChannel(player);
player.Comms = consoleCommChannel;
_tournament.RegisterPlayer(player);
ConsoleUi.WriteTextLine(string.Format("Registered player \"{0}\" with auto-ID \"{1}\".", name, id));
char readValue = ConsoleUi.WriteTextThenReadKey("Do you want to add another player (Y/n)?");
registerMore = (readValue == 'Y' || readValue == 'y' || readValue == (char)13);
}
}
private void Edit(object sender, MouseButtonEventArgs e)
{
var item = (sender as ListViewItem);
if (item != null)
{
try {
var tournament = item.DataContext as Tournament;
var dataItem = db.Tournaments.Find(tournament.Id);
this.DataContext = dataItem;
TournamentPlayers.Visibility = Visibility.Visible;
var tournamentPlayer = new TournamentPlayer();
tournamentPlayer.TournamentId = dataItem.Id;
TournamentPlayers.DataContext = tournamentPlayer;
cmbPlayers.SelectedItem = null;
lstPlayers.ItemsSource = dataItem.TournamentPlayers.ToList();
}catch (Exception esd)
{
string asd = "";
}
}
}
public TournamentPlayer JoinTournament(JoinTournamentRequest request)
{
new RequestValidator <JoinTournamentRequest>(request)
.Assert();
var tournament = mReposManager.TournamentsRepository.GetById(request.TournamentId);
var invites = tournament.IsOpen
? null
: mReposManager.TournamentsRepository.FindTournamentInvite(request.TournamentId, request.UserId,
request.TeamId ?? Guid.Empty).ToList();
if (!tournament.IsOpen && !invites.Any())
{
throw new BusinsessLogicException("NOTINVITED", "Not invited on closed tournament");
}
foreach (var playerInvite in invites.Where(el => el.Player.HasValue))
{
if (playerInvite.Used)
{
throw new BusinsessLogicException("ALREADYPARTICIPATED", "Already in tournament");
}
mReposManager.TournamentsRepository.UseTournamentInvite(playerInvite.Id.Value);
}
var newPlayer = new TournamentPlayer
{
PlayerId = request.UserId,
TeamId = request.TeamId,
TournamentId = request.TournamentId
};
mReposManager.TournamentsRepository.AddTournamentPlayer(newPlayer);
return(newPlayer);
}
public ConsoleCommChannel(TournamentPlayer player)
{
_playerCallsign = player.Name;
}
public TournamentGame(TournamentPlayer playerOne, TournamentPlayer playerTwo)
{
_playerOne = playerOne;
_playerTwo = playerTwo;
}
public static List <Tournament> ParseHLReport(string filepath, RTADatabaseContext context)
{
var tournaments = new List <Tournament>();
var data = File.ReadAllText(filepath).Split(new[] { "@tourn@" }, StringSplitOptions.RemoveEmptyEntries);
foreach (var entry in data)
{
var tournEntry = entry.Split(new[] { "@group@" }, StringSplitOptions.RemoveEmptyEntries);
var tournamentGroups = new List <TournamentGroup>();
var tournamentPlayers = new List <TournamentPlayer>();
var tournData = tournEntry[0].Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
var mapVersion = tournData[7];
var map = context.Maps.FirstOrDefault(m => m.Version == mapVersion);
if (map == null)
{
map = new Map {
Version = mapVersion
};
context.Maps.Add(map);
}
var tournament = new Tournament
{
IsFinished = true,
IsOfficial = true,
IsArchived = true,
NameRus = tournData[0],
NameEng = tournData[1],
Year = int.Parse(tournData[2]),
IsSeasonal = bool.Parse(tournData[3]),
Season = byte.Parse(tournData[4]),
IsPrivate = bool.Parse(tournData[5]),
DateCreated = DateTime.ParseExact(tournData[6], "yyyy.MM.dd", null),
Map = map,
Description = new TournamentDescription
{
//ContentRus =
//ContentEng =
}
};
for (int i = 1; i < tournEntry.Length; i++)
{
var groupEntry = tournEntry[i].Split('#');
var groupData = groupEntry[0].Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
var group = new TournamentGroup
{
NameRus = groupData[0],
NameEng = groupData[1],
GroupFormatId = byte.Parse(groupData[2])
};
var matches = new List <Match>();
var tournamentGroupPlayers = new List <TournamentGroupPlayer>();
var matchData = groupEntry[1].Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
foreach (var line in matchData)
{
var matchEntry = line.Replace("[confirmed]", "").Replace("[/confirmed]", "").
Replace("[open]", "").Replace("[/open]", "").Replace("[denied]", "").Replace("[/denied]", "").Split(';');
var players = matchEntry[0].Split(' ');
var player1Name = players[0];
var player2Name = players[2];
var player1 = context.Players.FirstOrDefault(p => p.Name == player1Name);
if (player1 == null)
{
player1 = new Player
{
Name = player1Name,
GuidKey = Guid.NewGuid().ToString(),
Stats = new PlayerStats
{
RatingClass = "B",
RatingPointsCurrent = 1200,
RatingPointsMax = 1200
}
};
context.Players.Add(player1);
}
var player2 = context.Players.FirstOrDefault(p => p.Name == player2Name);
if (player2 == null)
{
player2 = new Player
{
Name = player2Name,
GuidKey = Guid.NewGuid().ToString(),
Stats = new PlayerStats
{
RatingClass = "B",
RatingPointsCurrent = 1200,
RatingPointsMax = 1200
}
};
context.Players.Add(player2);
}
var games = new List <Game>();
for (int j = 1; j < matchEntry.Length - 2; j++)
{
var items = matchEntry[j].Replace(",", "").
Replace("Lazlo", "Laszlo").Replace("Shadwyn", "Ylaya").Replace("Gilrean", "Gilraen").Replace("Vlad", "Vladimir").Replace("Timerkhan", "Temkhan").
Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
if (items[0] != "?" && items[4] != "?")
{
var faction1Id = factionDictEng[items[0]];
var hero1 = items[1];
if (hero1 == "?" && faction1Id == 1)
{
hero1 = "Temkhan";
}
else if (hero1 == "?" && faction1Id == 6)
{
hero1 = "Arthas";
}
var faction2Id = factionDictEng[items[3]];
var hero2 = items[4];
if (hero2 == "?" && faction1Id == 1)
{
hero2 = "Temkhan";
}
else if (hero2 == "?" && faction1Id == 6)
{
hero2 = "Arthas";
}
if (hero1 != "?" && hero2 != "?")
{
bool player1Won = items[2] == ">";
var game = new Game
{
IsConfirmed = true,
Faction1Id = faction1Id,
Hero1Id = context.Heroes.FirstOrDefault(h => h.NameEng == hero1).Id,
Player1Won = player1Won,
Faction2Id = faction2Id,
Hero2Id = context.Heroes.FirstOrDefault(h => h.NameEng == hero2).Id,
DateSubmitted = DateTime.ParseExact(matchEntry[matchEntry.Length - 1], "yyyy.MM.dd", null),
};
SeedStatsUpdater.UpdateStats(player1.Stats, player2.Stats, faction1Id, faction2Id, player1Won);
context.SaveChanges();
games.Add(game);
}
}
}
var tournamentPlayer = tournamentPlayers.FirstOrDefault(tp => tp.Player == player1);
if (tournamentPlayer == null)
{
tournamentPlayer = new TournamentPlayer
{
Player = player1
};
tournamentPlayers.Add(tournamentPlayer);
}
if (!tournamentGroupPlayers.Any(tgp => tgp.TournamentPlayer == tournamentPlayer))
{
tournamentGroupPlayers.Add(new TournamentGroupPlayer {
TournamentPlayer = tournamentPlayer
});
}
tournamentPlayer = tournamentPlayers.FirstOrDefault(tp => tp.Player == player2);
if (tournamentPlayer == null)
{
tournamentPlayer = new TournamentPlayer
{
Player = player2
};
tournamentPlayers.Add(tournamentPlayer);
}
if (!tournamentGroupPlayers.Any(tgp => tgp.TournamentPlayer == tournamentPlayer))
{
tournamentGroupPlayers.Add(new TournamentGroupPlayer {
TournamentPlayer = tournamentPlayer
});
}
var date = matchEntry[matchEntry.Length - 1];
var score = matchEntry[matchEntry.Length - 2].Split(' ');
var match = new Match
{
Player1 = player1,
Player2 = player2,
Games = games,
IsFinished = true,
DateFinished = DateTime.ParseExact(date, "yyyy.MM.dd", null),
Player1Score = int.Parse(score[0]),
Player2Score = int.Parse(score[2]),
};
matches.Add(match);
}
group.Matches = matches;
group.TournamentGroupPlayers = tournamentGroupPlayers;
tournamentGroups.Add(group);
}
tournament.TournamentPlayers = tournamentPlayers;
tournament.TournamentGroups = tournamentGroups;
tournaments.Add(tournament);
}
;
return(tournaments);
}
public void InformOfGameAgainst(TournamentPlayer opponent, int numberOfTurns, int dynamiteLimit)
{
_bot.InformOfGameAgainst(opponent, numberOfTurns, dynamiteLimit);
}
public TournamentMatch(TournamentPlayer player1, TournamentPlayer player2)
{
Player1 = player1;
Player2 = player2;
}
public void InformOfGameAgainst(TournamentPlayer opponent, int numberOfTurns, int dynamiteLimit)
{
_webAccess.UploadValues("/start", new NameValueCollection {
{ OPPONENT_ID_KEY, opponent.Id }, { OPPONENT_NAME_KEY, opponent.Name }, { NUM_OF_TURNS_KEY, numberOfTurns.ToString() }, { DYNAMITE_LIMIT_KEY, dynamiteLimit.ToString() }
});
}
public void DeleteTournamentPlayer(int TournamentPlayerID)
{
TournamentPlayer tournamentPlayer = context.TournamentPlayers.Find(TournamentPlayerID);
context.TournamentPlayers.Remove(tournamentPlayer);
}
public void InsertTournamentPlayer(TournamentPlayer tournamentPlayer)
{
context.TournamentPlayers.Add(tournamentPlayer);
}
public void InformOfGameAgainst(TournamentPlayer opponent, int numberOfTurns, int dynamiteLimit)
{
_currentOpponent = opponent;
_currentRoundLength = numberOfTurns;
_currentDynamiteLimit = dynamiteLimit;
}
private void setBackgroundColor(TournamentPlayer player, RoundState state)
{
switch (state)
{
case RoundState.Empty:
if (slotType == RoundType.final)
{
setColor(TournamentColors.emptyGoldTint, true);
}
else if (slotType == RoundType.loser)
{
setColor(TournamentColors.emptyRedTint, false);
}
else
{
setColor(TournamentColors.empty, false);
}
break;
case RoundState.Idle:
if (slotType == RoundType.final)
{
setColor(TournamentColors.overOverGoldTint, true);
}
else
{
setColor(TournamentColors.idle, false);
}
break;
case RoundState.Playing: setColor(TournamentColors.playing, false); break;
case RoundState.Over:
if (player.isWinning)
{
if (slotType == RoundType.final)
{
setColor(TournamentColors.overOverGoldTint, true);
}
else
{
setColor(TournamentColors.overWon, false);
}
}
else
{
if (slotType == RoundType.loser)
{
setColor(TournamentColors.overLostRedTint, false);
}
else if (slotType == RoundType.final)
{
setColor(TournamentColors.overLostSilverTint, true);
}
else
{
setColor(TournamentColors.overLost, false);
}
}
break;
case RoundState.Lobby:
if (player != null && player.isReady)
{
setColor(TournamentColors.lobbyReady, true);
}
else
{
setColor(TournamentColors.lobbyNotReady, true);
}
break;
}
}
public void setPlayer(TournamentPlayer player, RoundState state)
{
text.text = player.info.username;
username = player.info.username;
setBackgroundColor(player, state);
}
public void UpdateTournamentPlayer(TournamentPlayer tournamentPlayer)
{
context.Entry(tournamentPlayer).State = EntityState.Modified;
}
public void InformOfGameAgainst(TournamentPlayer opponent, int numberOfTurns, int dynamiteLimit)
{
_dynamiteLimit = dynamiteLimit;
}
public void InformOfGameAgainst(TournamentPlayer opponent, int numberOfTurns, int dynamiteLimit)
{
ConsoleUi.WriteTextLine(CreatePlayerPrefix() + "your opponent for this round is " + opponent.Name + ". Number of turns is " + numberOfTurns + ", and dynamite limit is " + dynamiteLimit + ".");
}
