public async Task <List <PlayerGameViewItem> > GetScoreCount()
        {
            Dictionary <Player, List <Card> > playerCardsLastGame = await DefinePlayersFromLastGame();

            var playerViewItemList = new List <PlayerGameViewItem>();

            foreach (var player in playerCardsLastGame)
            {
                IEnumerable <Card> cardsList = await _playerRepository.GetAllCardsFromPlayer(player.Key.Id, _round);

                int score = cardsList.ToList().Sum(card => card.Value);
                PlayerGameViewItem playerViewItem = new PlayerGameViewItem();
                playerViewItem.Id         = player.Key.Id;
                playerViewItem.Name       = player.Key.Name;
                playerViewItem.GameNumber = player.Key.GameNumber;
                playerViewItem.PlayerType = player.Key.PlayerType;
                playerViewItem.Score      = player.Value.Sum(c => c.Value);
                foreach (var card in player.Value)
                {
                    playerViewItem.Cards.Add(new CardViewItem {
                        Id = card.Id, Value = card.Value
                    });
                }

                playerViewItemList.Add(playerViewItem);
            }

            return(playerViewItemList);
        }
Esempio n. 2
0
        public async Task <bool> IsGameEnded(bool takeCard)
        {
            List <PlayerGameViewItem> playerViewItemList = await GetScoreCount();

            bool isGameEnded = false;
            var  cardCount   = new List <int>();

            foreach (var playerScore in playerViewItemList.Where(x => x.PlayerType != _personPlayerType))
            {
                int scoreValue = playerScore.Score;
                cardCount.Add(scoreValue);
            }

            isGameEnded = cardCount.TrueForAll(c => c >= 17);
            PlayerGameViewItem playerViewItem =
                playerViewItemList.SingleOrDefault(x => x.PlayerType == _personPlayerType);
            int cardSum = playerViewItem.Cards.Sum(c => c.Value);

            if (cardSum < 21 && takeCard != false)
            {
                isGameEnded = false;
            }

            return(isGameEnded);
        }
        public async Task <bool> IsUserBusted()
        {
            int scoreMaxValue = 21;

            List <PlayerGameViewItem> playerViewItemList = await GetScoreCount();

            PlayerGameViewItem playerViewItem =
                playerViewItemList.SingleOrDefault(x => x.PlayerType == _personPlayerType);
            int cardSum = playerViewItem.Cards.Sum(x => x.Value);

            if (cardSum >= scoreMaxValue)
            {
                return(true);
            }

            return(false);
        }
        //public async Task<MoreOrEnoughGameView> MoreOrEnough(bool takeCard = false)
        //{
        //    bool isGameEnded = await IsGameEnded(takeCard);


        //    for (; isGameEnded == false;)
        //    {
        //        var isUserBusted = await IsUserBusted();
        //        if (takeCard && !isUserBusted)
        //        {
        //            await TakeCardIfNotEnough(takeCard);
        //            isGameEnded = await IsGameEnded(takeCard);
        //            isUserBusted = await IsUserBusted();
        //            if (!isUserBusted)
        //            {
        //                break;
        //            }

        //            takeCard = false;
        //        }

        //        if (!takeCard)
        //        {
        //            await TakeCardIfNotEnough(takeCard);
        //            isGameEnded = await IsGameEnded(takeCard);
        //        }
        //    }

        //    Dictionary<Player, List<Card>> playerCardsLastGame = await DefinePlayersFromLastGame();

        //    List<PlayerGameViewItem> playerViewItemList = new List<PlayerGameViewItem>();

        //    foreach (var player in playerCardsLastGame)
        //    {
        //        PlayerGameViewItem playerViewItem = new PlayerGameViewItem();
        //        playerViewItem.Id = player.Key.Id;
        //        playerViewItem.Name = player.Key.Name;
        //        playerViewItem.GameNumber = player.Key.GameNumber;
        //        playerViewItem.PlayerType = player.Key.PlayerType;
        //        playerViewItem.Score = player.Value.Sum(c=>c.Value);
        //        foreach (var card in player.Value)
        //        {
        //            playerViewItem.Cards.Add(new CardViewItem { Id = card.Id, Value = card.Value });
        //        }

        //        playerViewItemList.Add(playerViewItem);
        //    }

        //    CountSum(ref playerViewItemList);

        //    MoreOrEnoughGameView moreOrEnoughViewModel = new MoreOrEnoughGameView();
        //    moreOrEnoughViewModel.Players = playerViewItemList;

        //    return moreOrEnoughViewModel;
        //}


        /////////////////////////////////////////////////////////
        ///

        public async Task <MoreOrEnoughGameView> More()
        {
            bool isGameEnded = await IsGameEnded(false);

            if (!isGameEnded)
            {
                await TakeCardIfNotEnough(true);
            }
            var isUserBusted = await IsUserBusted();

            if (isUserBusted)
            {
                await Enough();
            }

            Dictionary <Player, List <Card> > playerCardsLastGame = await DefinePlayersFromLastGame();

            List <PlayerGameViewItem> playerViewItemList = new List <PlayerGameViewItem>();

            foreach (var player in playerCardsLastGame)
            {
                PlayerGameViewItem playerViewItem = new PlayerGameViewItem();
                playerViewItem.Id         = player.Key.Id;
                playerViewItem.Name       = player.Key.Name;
                playerViewItem.GameNumber = player.Key.GameNumber;
                playerViewItem.PlayerType = player.Key.PlayerType;
                playerViewItem.Score      = player.Value.Sum(c => c.Value);
                foreach (var card in player.Value)
                {
                    playerViewItem.Cards.Add(new CardViewItem {
                        Id = card.Id, Value = card.Value
                    });
                }

                playerViewItemList.Add(playerViewItem);
            }

            CountSum(ref playerViewItemList);

            MoreOrEnoughGameView moreOrEnoughViewModel = new MoreOrEnoughGameView();

            moreOrEnoughViewModel.Players = playerViewItemList;

            return(moreOrEnoughViewModel);
        }
        public async Task <StartGameView> Start(int botCount)
        {
            //await SetDeck();
            await SetBotCount(botCount);

            int handOverCount = 2;

            _round++;

            for (int i = 0; i < handOverCount; i++)
            {
                await GiveCardToEachPlayer();
            }

            Dictionary <Player, List <Card> > playerCardsLastGame = await DefinePlayersFromLastGame();

            List <PlayerGameViewItem> playerViewItemList = new List <PlayerGameViewItem>();

            foreach (var player in playerCardsLastGame)
            {
                PlayerGameViewItem playerViewItem = new PlayerGameViewItem();
                playerViewItem.Id         = player.Key.Id;
                playerViewItem.Name       = player.Key.Name;
                playerViewItem.GameNumber = player.Key.GameNumber;
                playerViewItem.PlayerType = player.Key.PlayerType;
                playerViewItem.Score      = player.Value.Sum(c => c.Value);
                foreach (var card in player.Value)
                {
                    playerViewItem.Cards.Add(new CardViewItem {
                        Id = card.Id, Value = card.Value
                    });
                }

                playerViewItemList.Add(playerViewItem);
            }

            CountSum(ref playerViewItemList);

            StartGameView startViewModel = new StartGameView();

            startViewModel.Players = playerViewItemList;

            return(startViewModel);
        }
        public async Task <HistoryGameView> GetHistory()
        {
            IEnumerable <PlayerCard> gamePlayersList = _playerCardRepository.GetAll();
            int maxRound = gamePlayersList.Max(r => r.CurrentRound);

            var history = new HistoryGameView();

            for (int i = 1; i <= maxRound; i++)
            {
                List <PlayerCard> playersList = await _playerRepository.GetPlayersByRound(i);

                foreach (var item in playersList)
                {
                    IEnumerable <Card> cardList = await _playerRepository.GetAllCardsFromPlayer(item.PlayerId, i);

                    Player player = await _playerRepository.GetByIdAsync(item.PlayerId);

                    PlayerGameViewItem playerModel = new PlayerGameViewItem();
                    playerModel.Id         = player.Id;
                    playerModel.Name       = player.Name;
                    playerModel.GameNumber = player.GameNumber;
                    playerModel.PlayerType = player.PlayerType;
                    playerModel.Score      = cardList.Sum(x => x.Value);
                    playerModel.Round      = i;
                    foreach (var card in cardList)
                    {
                        playerModel.Cards.Add(new CardViewItem
                        {
                            Id    = card.Id,
                            Value = card.Value
                        });
                    }


                    history.Players.Add(playerModel);
                }
            }

            return(history);
        }