public async Task <PlayerResponse> JoinGame(string gameId, string userId) { var game = organizedGamesRepository.Get(gameId); if (game is null) { throw new NotFoundException("game does not exist"); } if (game.StartTime.CompareTo(DateTime.UtcNow) <= 0) { throw new InvalidActionException("game has already started"); } var playerFound = gameParticipantsRepository.Filter(x => x.GameId == gameId && x.PlayerId == userId).FirstOrDefault(); if (!(playerFound is null)) { throw new InvalidActionException("player is already in game"); } var players = gameParticipantsRepository.GetParticipantsByGame(gameId).Count(); var participant = new GameParticipant { GameId = gameId, PlayerId = userId, StartTime = game.StartTime.Add(players * game.StartInterval) }; var added = await gameParticipantsRepository.Add(participant); return(mapper.Map <PlayerResponse>(added)); }
public HelperParticipant(GameParticipant participant, ParticipantIdentity identity) { ParticipantId = participant.ParticipantId; ChampionId = participant.ChampionId; Spell1Id = participant.Spell1Id; Spell2Id = participant.Spell2Id; Stats = participant.Stats; Identity = identity.Player; }
public LobbyMember(GameParticipant m) : this(m.SummonerInternalName) { Name = m.SummonerName; if (m is BotParticipant) { var split = m.SummonerInternalName.Split('_'); var name = split[1]; Champ = DataDragon.ChampData.Value.data[name].key; } }
public IActionResult DeleteGameParticipant(GameParticipant participant) { try { gameParticipantService.DeleteGameParticipant(participant); return(Ok()); } catch (Exception) { return(BadRequest()); } }
public IActionResult UpdateGameParticipant(GameParticipant participant) { try { gameParticipantService.UpdateGameParticipant(participant); return(CreatedAtAction("UpdateGameParticipant", participant)); } catch (Exception) { return(BadRequest()); } }
public void ShouldGetCorrectValueForHand() { var card1 = new Card { Suit = Suit.Spades, FaceValue = Tuple.Create(FaceValue.King, 10, 10) }; var card2 = new Card { Suit = Suit.Diamonds, FaceValue = Tuple.Create(FaceValue.Five, 5, 5) }; var participant = new GameParticipant(); participant.Hand.Add(card1); participant.Hand.Add(card2); Assert.AreEqual(15, participant.HandTotalValue); }
// Method to initialize game state public GameState AssignParticipants(GameState oldState, IList <INUserPresence> presence) { string[] roles = { "0", "1" }; int i = 0; List <GameParticipant> gameParticipants = new List <GameParticipant> (); foreach (var user in presence) { GameParticipant gp = new GameParticipant(); gp.id = user.UserId; gp.role = roles [i]; gameParticipants.Add(gp); i++; } oldState.whoseTurn = "0"; oldState.participants = gameParticipants; return(oldState); }
private GameMember GetMember(GameParticipant part, ref GameMember me) { GameMember member; var player = part as PlayerParticipant; if (player != null) { PlayerChampionSelectionDTO selection; TradeContractDTO trade; selections.TryGetValue(player.SummonerInternalName, out selection); trades.TryGetValue(player.SummonerInternalName, out trade); bool canTrade = potentialTraders?.Contains(player.SummonerInternalName) ?? false; member = new GameMember(player, selection, trade, canTrade, lastGameDto.PickTurn); var pojo = player as ARAMPlayerParticipant; if (pojo != null) { member.Reroll = new RerollState(pojo.PointSummary); } if (player.SummonerId == session.Me.SummonerId) { me = member; } } else if (part is BotParticipant) { member = new GameMember((BotParticipant)part, lastGameDto.PickTurn); } else if (part is ObfuscatedParticipant) { member = new GameMember((ObfuscatedParticipant)part, lastGameDto.PickTurn); } else { throw new NotImplementedException(part.GetType().FullName); } standardMembers[member.Id] = part; return(member); }
private static async Task RunDemoAsync() { Container gamesContainer = Program.database.GetContainer(containerId); // This code demonstrates interactions by a multi-player game service that hosts games with the database to save game state. // In this fictional game, players move about the 10x10 map and try to find balls. // The objective is to collect 2 balls of the same color, or a golden ball if one appears. // After 5 minutes, if the game is not complete, the player with highest number of balls wins. int gameId = 420; int playerCount = 3; int ballCount = 4; List <GameBall> balls = new List <GameBall>(); List <GameParticipant> players = new List <GameParticipant>(); Console.WriteLine("At the start of the game, the balls are added on the map, and the players are added ..."); // The below batch request is used to create the game balls and participants in an atomic fashion. TransactionalBatchResponse gameStartResponse = await gamesContainer.CreateTransactionalBatch(new PartitionKey(gameId)) .CreateItem <GameBall>(GameBall.Create(gameId, Color.Red, 4, 2)) .CreateItem <GameBall>(GameBall.Create(gameId, Color.Blue, 6, 4)) .CreateItem <GameBall>(GameBall.Create(gameId, Color.Blue, 8, 7)) .CreateItem <GameBall>(GameBall.Create(gameId, Color.Red, 8, 8)) .CreateItem <GameParticipant>(GameParticipant.Create(gameId, "alice")) .CreateItem <GameParticipant>(GameParticipant.Create(gameId, "bob")) .CreateItem <GameParticipant>(GameParticipant.Create(gameId, "carla")) .ExecuteAsync(); GameParticipant alice, bob, carla; GameBall firstBlueBall, secondRedBall; using (gameStartResponse) { // Batch requests do not throw exceptions on execution failures as long as the request is valid, so we need to check the response status explicitly. // A HTTP 200 (OK) StatusCode on the batch response indicates that all operations succeeded. // An example later demonstrates a failure case. if (!gameStartResponse.IsSuccessStatusCode) { // Log and handle failure LogFailure(gameStartResponse); return; } // Refresh in-memory state from response. // The TransactionalBatchResponse has a list of TransactionalBatchOperationResult, one for each operation within the batch request in the order // the operations were added to the TransactionalBatch. for (int index = 0; index < ballCount; index++) { // The GetOperationResultAtIndex method returns the result of the operation at the given index with a Resource deserialized to the provided type. TransactionalBatchOperationResult <GameBall> gameBallResult = gameStartResponse.GetOperationResultAtIndex <GameBall>(index); balls.Add(gameBallResult.Resource); } firstBlueBall = balls[1]; secondRedBall = balls[3]; for (int index = ballCount; index < gameStartResponse.Count; index++) { players.Add(gameStartResponse.GetOperationResultAtIndex <GameParticipant>(index).Resource); } alice = players.Single(p => p.Nickname == "alice"); bob = players.Single(p => p.Nickname == "bob"); carla = players.Single(p => p.Nickname == "carla"); } PrintState(players, balls); Console.WriteLine("Alice goes to 6, 4 and finds a blue ball ..."); alice.BlueCount++; // Upserts maybe used to replace items or create them if they are not already present. // An existing item maybe replaced along with concurrency checks the ETag returned in the responses of earlier requests on the item // or without these checks if they are not required. // Item deletes may also be a part of batch requests. TransactionalBatchResponse aliceFoundBallResponse = await gamesContainer.CreateTransactionalBatch(new PartitionKey(gameId)) .UpsertItem <ParticipantLastActive>(ParticipantLastActive.Create(gameId, "alice")) .ReplaceItem <GameParticipant>(alice.Nickname, alice, new TransactionalBatchItemRequestOptions { IfMatchEtag = alice.ETag }) .DeleteItem(firstBlueBall.Id) .ExecuteAsync(); using (aliceFoundBallResponse) { if (!aliceFoundBallResponse.IsSuccessStatusCode) { // Log and handle failure alice.BlueCount--; LogFailure(aliceFoundBallResponse); return; } // Refresh in-memory state from response. balls.Remove(firstBlueBall); // We only update the etag as we have the rest of the state we care about here already as needed. alice.ETag = aliceFoundBallResponse[1].ETag; } PrintState(players, balls); Console.WriteLine("Bob goes to 8, 8 and finds a red ball ..."); bob.RedCount++; // Stream variants for all batch operations that accept an item are also available for use when the item is available as a Stream. Stream bobIsActiveStream = ParticipantLastActive.CreateStream(gameId, "bob"); Stream bobAsStream = Program.AsStream(bob); using (bobIsActiveStream) using (bobAsStream) { TransactionalBatchResponse bobFoundBallResponse = await gamesContainer.CreateTransactionalBatch(new PartitionKey(gameId)) .UpsertItemStream(bobIsActiveStream) .ReplaceItemStream(bob.Nickname, bobAsStream, new TransactionalBatchItemRequestOptions { IfMatchEtag = bob.ETag }) .DeleteItem(secondRedBall.Id) .ExecuteAsync(); using (bobFoundBallResponse) { if (!bobFoundBallResponse.IsSuccessStatusCode) { // Log and handle failure. bob.RedCount--; LogFailure(bobFoundBallResponse); return; } // Refresh in-memory state from response. balls.Remove(secondRedBall); // The resultant item for each operation is also available as a Stream that can be used for example if the response is just // going to be transferred to some other system. Stream updatedPlayerAsStream = bobFoundBallResponse[1].ResourceStream; bob = Program.FromStream <GameParticipant>(updatedPlayerAsStream); } } PrintState(players, balls); Console.WriteLine("A golden ball appears near each of the players to select an instant winner ..."); TransactionalBatchResponse goldenBallResponse = await gamesContainer.CreateTransactionalBatch(new PartitionKey(gameId)) .CreateItem <GameBall>(GameBall.Create(gameId, Color.Gold, 2, 2)) .CreateItem <GameBall>(GameBall.Create(gameId, Color.Gold, 6, 3)) // oops - there is already a ball at 8, 7 .CreateItem <GameBall>(GameBall.Create(gameId, Color.Gold, 8, 7)) .ExecuteAsync(); using (goldenBallResponse) { // If an operation within the TransactionalBatch fails during execution, the TransactionalBatchResponse will have a status code of the failing operation. // The TransactionalBatchOperationResult entries within the response can be read to get details about the specific operation that failed. // The failing operation (for example if we have a conflict because we are trying to create an item // that already exists) will have the StatusCode on its corresponding TransactionalBatchOperationResult set to the actual failure status // (HttpStatusCode.Conflict in this example). All other result entries will have a status code of HTTP 424 Failed Dependency. // In case any operation within a TransactionalBatch fails, no changes from the batch will be committed. // Other status codes such as HTTP 429 (Too Many Requests) and HTTP 5xx on server errors may also be returned on the TransactionalBatchResponse. if (!goldenBallResponse.IsSuccessStatusCode) { if (goldenBallResponse.StatusCode == HttpStatusCode.Conflict) { for (int index = 0; index < goldenBallResponse.Count; index++) { TransactionalBatchOperationResult operationResult = goldenBallResponse[index]; if ((int)operationResult.StatusCode == 424) { // This operation failed because it was in a TransactionalBatch along with another operation where the latter was the actual cause of failure. continue; } else if (operationResult.StatusCode == HttpStatusCode.Conflict) { Console.WriteLine("Creation of the {0}rd golden ball failed because there was already an existing ball at that position.", index + 1); } } } else { // Log and handle other failures LogFailure(goldenBallResponse); return; } } } PrintState(players, balls); Console.WriteLine("We need to end the game now; determining the winner as the player with highest balls ..."); // Batch requests may also be used to atomically read multiple items with the same partition key. TransactionalBatchResponse playersResponse = await gamesContainer.CreateTransactionalBatch(new PartitionKey(gameId)) .ReadItem(alice.Nickname) .ReadItem(bob.Nickname) .ReadItem(carla.Nickname) .ExecuteAsync(); GameParticipant winner = null; bool isTied = false; using (playersResponse) { if (!playersResponse.IsSuccessStatusCode) { // Log and handle failure LogFailure(playersResponse); return; } for (int index = 0; index < playerCount; index++) { GameParticipant current; if (index == 0) { // The item returned can be made available as the required POCO type using GetOperationResultAtIndex. // A single batch request can be used to read items that can be deserialized to different POCOs as well. current = playersResponse.GetOperationResultAtIndex <GameParticipant>(index).Resource; } else { // The item returned can also instead be accessed directly as a Stream (for example to pass as-is to another component). Stream aliceInfo = playersResponse[index].ResourceStream; current = Program.FromStream <GameParticipant>(aliceInfo); } if (winner == null || current.TotalCount > winner.TotalCount) { winner = current; isTied = false; } else if (current.TotalCount == winner.TotalCount) { isTied = true; } } } if (!isTied) { Console.WriteLine($"{winner.Nickname} has won the game!\n"); } else { Console.WriteLine("The game is a tie; there is no clear winner.\n"); } }
public void DeleteGameParticipant(GameParticipant participant) { context.GameParticipants.Remove(participant); context.SaveChanges(); }
public void UpdateGameParticipant(GameParticipant participant) { context.GameParticipants.Update(participant); context.SaveChanges(); }
public ActionResult AddParticipantToGame(int particId, int gameId) { var game = DataContext.Games.Include("Sport").Single(x => x.Id == gameId); if (game.GameParticipants.Any(x => x.ParticipantId == particId)) { return(Content("Уже добавлен")); } if (game.GameParticipants.Count == game.Sport.SidesCountMax) { return(Content("Превышен лимит команд")); } var participant = new GameParticipant { GameId = gameId, ParticipantId = particId }; DataContext.GameParticipants.Add(participant); if (game.Sport.IsTeamSport) { var team = DataContext.Teams.Single(x => x.Id == particId); foreach (var player in team.Players) { var particPlayer = new GameParticipantPlayer { Player = player, GameParticipant = participant, }; DataContext.GameParticipantPlayers.Add(particPlayer); // свойства var props = player.Properties.Where(x => x.PlayerPropertyType.IsDependsOnGame); foreach (var playerProperty in props) { DataContext.GameParticipantPlayerProps.Add(new GameParticipantPlayerProp { GameParticipantPlayer = particPlayer, PlayerPropertyType = playerProperty.PlayerPropertyType, PropValue = playerProperty.Value }); } } } else { var player = DataContext.Players.Single(x => x.Id == particId); var particPlayer = new GameParticipantPlayer { Player = player, GameParticipant = participant, }; DataContext.GameParticipantPlayers.Add(particPlayer); var props = player.Properties.Where(x => x.PlayerPropertyType.IsDependsOnGame); foreach (var playerProperty in props) { DataContext.GameParticipantPlayerProps.Add(new GameParticipantPlayerProp { GameParticipantPlayer = particPlayer, PlayerPropertyType = playerProperty.PlayerPropertyType, PropValue = playerProperty.Value }); } } DataContext.SaveChanges(); return(GetGameParticipants(gameId)); }
public void DeleteGameParticipant(GameParticipant participant) { repo.DeleteGameParticipant(participant); }
public void UpdateGameParticipant(GameParticipant participant) { repo.UpdateGameParticipant(participant); }
public void AddGameParticipant(GameParticipant participant) { repo.AddGameParticipant(participant); }
public bool CanMakeMoves(GameState gameState, string participantId) { GameParticipant gp = gameState.GetParticipantWithId(participantId); return(gameState.stage == 0 && gp.role == gameState.whoseTurn); }
public void AddGameParticipant(GameParticipant participant) { context.GameParticipants.Add(participant); context.SaveChanges(); }