public async Task <bool> UpdateGame(string id, [FromBody] GameServiceViewModel viewModel)
        {
            if (id == viewModel.Id)
            {
                var isUpdated = await _gameService.UpdateGame(viewModel);

                return(isUpdated);
            }
            return(false);
        }
        public async Task <ActionResult> CurrentGame(GameServiceViewModel viewModel)
        {
            var result = await _gameService.StartGame(viewModel);

            //if (result.isResultComplete)
            //{
            //    return View("GameFinnished", result);
            //}
            return(View(result));
        }
Beispiel #3
0
        public async Task <int> DeleteGame(GameServiceViewModel viewModel)
        {
            try
            {
                var result = await _gameRepository.Remove(DataMapper.Map(viewModel));

                return(result);
            }
            catch (Exception ex)
            {
                Logger.WriteLogToFile(ex.Message, "GameService", "DeleteGame");
                return(0);
            }
        }
Beispiel #4
0
        public async Task <RoundViewModel> StartGame(GameServiceViewModel viewFromUI) // Creating first round
        {
            var gameId = await CreateGame(viewFromUI.PlayerName, viewFromUI.BotQuantity);

            await CreateHuman(viewFromUI.PlayerName, gameId);

            if (viewFromUI.BotQuantity != 0)
            {
                await CreateBots(viewFromUI.BotQuantity, gameId);
            }
            await CreateDealer(gameId);

            var roundModel = MappingToViewModel(_rounds);

            await CheckPlayersForMoreThanTwentyOne(roundModel);

            var humanPlayer = GetHumanPlayer(roundModel.Users);
            var dealer      = GetDealer(roundModel.Users);

            if (humanPlayer.PlayerStatus == PlayerStatus.Lose)
            {
                await CheckDealer(roundModel.Users);
                await FinalPointsCount(roundModel.Users);

                roundModel.isResultComplete = true;
                return(roundModel);
            }
            if (dealer.PlayerStatus == PlayerStatus.Lose)
            {
                return(await FinalPointsCount(roundModel.Users));
            }

            await CheckPlayersForBlackJack(roundModel);

            humanPlayer = GetHumanPlayer(roundModel.Users);
            dealer      = GetDealer(roundModel.Users);
            if (humanPlayer.PlayerStatus == PlayerStatus.Winner)
            {
                await CheckDealer(roundModel.Users);

                return(await FinalPointsCount(roundModel.Users));
            }

            return(roundModel);
        }
Beispiel #5
0
        public async Task <bool> UpdateGame(GameServiceViewModel viewModel)
        {
            try
            {
                var entity = DataMapper.Map(viewModel);
                if (entity.Id != Guid.Empty)
                {
                    var result = await _gameRepository.Update(entity);

                    return(result);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLogToFile(ex.Message, "GameService", "UpdateGame");
                return(false);
            }
            return(false);
        }
Beispiel #6
0
        public static Game Map(GameServiceViewModel viewModel)
        {
            if (Guid.TryParse(viewModel.Id, out Guid id) && DateTime.TryParse(viewModel.Start, out DateTime startTime))
            {
                var entity = new Game()
                {
                    Id    = id,
                    Start = startTime,
                };
                if (DateTime.TryParse(viewModel.End, out DateTime endTime))
                {
                    entity.End = endTime;
                }

                return(entity);
            }

            return(new Game {
                Id = Guid.NewGuid()
            });
        }