public async Task <ResponseGameProcessGameView> StartGame(RequestGameStartOptionsGameView viewModel)
{
long playerId = await CheckPLayerName(viewModel.PlayerName) ? await CreatePlayerAndReturnId(viewModel) : await _playerRepository.GetPlayerIdByPlayerName(viewModel.PlayerName);
long gameId = await CreateGameAndReturnId(viewModel, playerId);
long roundId = await CreateRoundAndReturnId(gameId);
Player player = await _playerRepository.Get(playerId);
Player dealer = await _playerRepository.GetFirstPlayerByRole(PlayerRole.Dealer);
List <Player> botList = await _playerRepository.GetQuantityByRole(viewModel.BotsAmount, (int)PlayerRole.Bot);
var playerList = new List <Player>();
playerList.Add(player);
playerList.AddRange(botList);
playerList.Add(dealer);
List <PlayerRoundHand> playerRoundHandList = CreatePlayerRoundHands(playerList, roundId);
await _playerRoundHandRepository.CreateManyAsync(playerRoundHandList);
playerRoundHandList = await _playerRoundHandRepository.GetPLayerRoundHandListByRoundId(roundId);
var gameViewModel = new ResponseGameProcessGameView();
gameViewModel.Game = _maping.MapGameToGameGameProcessGameViewItem(await _gameRepository.Get(gameId));
gameViewModel.Round = _maping.MapRoundToRoundGameProcessGameViewItem(await _roundRepository.Get(roundId));
gameViewModel.Player = _maping.MapPlayerToPlayerGameProccessGameViewItem(playerList.Where(x => x.Role == PlayerRole.Player).FirstOrDefault(), playerRoundHandList);
gameViewModel.Dealer = _maping.MapPlayerToPlayerGameProccessGameViewItem(playerList.Where(x => x.Role == PlayerRole.Dealer).FirstOrDefault(), playerRoundHandList);
gameViewModel.Bots = _maping.MapPlayerListToPlayerGameProccessGameViewItem(playerList.Where(x => x.Role == PlayerRole.Bot).ToList(), playerRoundHandList);
return(gameViewModel);
}
public async Task <ResponseGetPlayersTwoCardsGameView> GetPlayersTwoCards(RequestGetPlayersTwoCardsGameView requestGetPlayersTwoCardsGameView)
{
Round round = await _roundRepository.Get(requestGetPlayersTwoCardsGameView.RoundId);
Game game = await _gameRepository.GetGameWithPlayerGames(round.GameId);
if (round == null || game == null)
{
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine(string.Format("RoundId: {0}", requestGetPlayersTwoCardsGameView.RoundId.ToString()));
for (int i = 0; i < requestGetPlayersTwoCardsGameView.Players.Count; i++)
{
stringBuilder.AppendLine(string.Format("PlayerId: {0}", requestGetPlayersTwoCardsGameView.Players[i]));
}
stringBuilder.AppendLine(string.Format("Message: {0}", SolutionConstants.BUSINESS_LOGIC_GET_ITEM_EXCEPTION_MESSAGE));
string message = stringBuilder.ToString();
throw new BusinessLogicGetItemException(message);
}
await GiveOutTwoCards(game.Id, requestGetPlayersTwoCardsGameView);
List <Hand> listHands = await _handRepository.GetListHandsWithCardsWithoutDeallerHandByRoundId(round.Id);
if (listHands == null)
{
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine(string.Format("RoundId: {0}", round.Id));
stringBuilder.AppendLine(string.Format("Message: {0}", SolutionConstants.BUSINESS_LOGIC_GET_ITEM_EXCEPTION_MESSAGE));
string message = stringBuilder.ToString();
throw new BusinessLogicGetItemException(message);
}
var responseView = new ResponseGetPlayersTwoCardsGameView();
for (int i = 0; i < listHands.Count; i++)
{
List <Card> cards = listHands[i].HandCards.Select(item => item.Card).ToList();
var responseViewItem = new GetPlayersTwoCardsGameViewItem();
responseViewItem.PlayerId = listHands[i].PlayerId;
responseViewItem.HandId = listHands[i].Id;
responseViewItem.Cards = _mapper.Map <List <Card>, List <CardGetPlayersTwoCardsGameViewItemItem> >(cards);
responseViewItem.Summary = listHands[i].Summary;
responseView.ListPlayersWithCards.Add(responseViewItem);
}
return(responseView);
}
public async Task <DetailsRoundHistoryView> GetRoundsDetailsByRoundId(int roundId)
{
Round round = await _roundRepository.Get(roundId);
Game game = await _gameRepository.Get(round.GameId);
Player player = await _playerRepository.Get(game.PlayerId);
Player dealer = await _playerRepository.GetFirstPlayerByRole(PlayerRole.Dealer);
List <Player> bots = await _playerRepository.GetQuantityByRole(game.PlayersAmount - 1, (int)PlayerRole.Bot);
var players = new List <Player>();
players.Add(player);
players.Add(dealer);
players.AddRange(bots);
List <PlayerRoundHand> hands = await _playerRoundHandRepository.GetPLayerRoundHandListByRoundId(round.Id);
var playerRoundHandId = new List <long>();
foreach (var hand in hands)
{
playerRoundHandId.Add(hand.Id);
}
List <Card> cards = await _cardRepository.GetPlayerRoundHandCards(playerRoundHandId);
var data = new DetailsRoundHistoryView();
data.Players = _maping.MapPlayersToPlayerDetailsRoundHistoryViewItem(players, hands, cards);
return(data);
}
public async Task <DTOs.MemberRound> Score(DTOs.ScoreRound request)
{
var round = await roundRepository.Get(request.Round.Id);
if (round == null)
{
throw new NotFoundException("Round", request.Round.Id);
}
var member = round.Members.FirstOrDefault(m => m.Member.Bandit.Id == request.Member.Id);
if (member == null)
{
throw new NotFoundException("Bandit", request.Member.Id);
}
member.ScoreRound(request.Score.ToModel());
await roundRepository.UpdateScoring(member);
if (round.AllScored())
{
await roundRepository.UpdateScoring(round.Sheriff);
}
return(member.ToDtoMember());
}
public void SaveRound(int gameId, List <bool> flags)
{
var roundPlayers = GetRoundPlayers(gameId).ToList();
for (int i = 0; i < roundPlayers.Count - 1; i++)
{
roundPlayers[i].IsWin = flags[i];
_roundPlayerRepository.Update(roundPlayers[i]);
}
int roundId = GetCurrentRoundId(gameId);
Round round = _roundRepository.Get(roundId);
round.IsCompleted = true;
_roundRepository.Update(round);
}
public async Task <bool> GameIsOver(Game game)
{
var rounds = await _roundRepository.Get(game);
if (game.RoundQuantity == rounds.Count())
{
return(true);
}
return(false);
}
public RoundInfo GetRoundInfo(int roundId)
{//TODO optimize
RoundInfo roundInfo = new RoundInfo();
RoundEntity roundEntity = _roundRepository.Get(roundId);
IEnumerable <ImageInRoundEntity> imageInRoundEntity = _imageInRoundRepository.GetAll().Where(x => x.RoundId == roundId);
roundInfo.GameId = roundEntity.GameId;
roundInfo.CorrectImageId = roundEntity.CorrectImageId;
roundInfo.GuessedImageId = roundEntity.GuessedImageId.Value;
roundInfo.Name = _imageRepository.Get(roundEntity.CorrectImageId).Name;
roundInfo.Images = imageInRoundEntity.Select(x => new Image {
Id = x.ImageId, Url = _imageRepository.Get(x.ImageId).Url
}).ToList();
roundInfo.AmountOfRoundsPlayed = RoundsPlayedInGame(roundEntity.GameId);
roundInfo.TotalRounds = ROUNDS_PER_GAME;
return(roundInfo);
}
public async Task <DTOs.RoundDetails> Notify(int roundId)
{
var round = await roundRepository.Get(roundId);
if (round == null)
{
throw new NotFoundException("Round", roundId);
}
if (!round.AllScored())
{
return(round.ToDtoDetails());
}
var band = await bandRepository.Get(round.Sheriff.Member.Band.Id);
var message = Notifications.RoundResults(band, round);
band.Members.ForEach(async m => await notifications.Send(message, to: m.Bandit));
return(round.ToDtoDetails());
}
public IHttpActionResult Get(int id)
{
return(Json(roundRepository.Get(id)));
}
public ActionResult Details(int id)
{
var round = _roundRepository.Get(id);
return(CheckForNullAndExecute(round, () => View(round)));
}
public Round Get(int id)
{
return(_roundRepository.Get(id));
}
public ActionResult Get(int id)
{
var apiResult = TryExecute(() => _roundRepository.Get(id), "Interview Round fetched sucessfully");
return(Json(apiResult, JsonRequestBehavior.AllowGet));
}
