コード例 #1
0
        public void PlayingCardThatsNotInHandShouldBeInvalid()
        {
            var cards = new List<Card>() { new Card(CardSuit.Diamond, CardType.Jack) };
            var action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Club, CardType.Jack), Announce.None);
            var state = new FinalRoundState();
            var context = new PlayerTurnContext(state, new Card(CardSuit.Club, CardType.Jack), 0);

            Assert.IsFalse(this.validater.IsValid(action, context, cards));
        }
コード例 #2
0
 public void PlayingCardFromHandShouldBeValid()
 {
     var cards = new List<Card>() { new Card(CardSuit.Club, CardType.Ace) };
     var action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Club, CardType.Ace), Announce.None);
     var state = new FinalRoundState();
     var context = new PlayerTurnContext(state, new Card(CardSuit.Club, CardType.Jack), 0);
     
     Assert.IsTrue(validator.IsValid(action, context, cards));
 }
コード例 #3
0
        public PlayerAction Handle(DecisionMakingContext context)
        {
            this.announce = this.GetAnnounces(context);
            if (this.IsMatch(context))
            {
                return this.announce;
            }

            return this.Next.Handle(context);
        }
コード例 #4
0
        public void PlayerChangesTrumpWithQueen_ShouldBeInvalid()
        {
            var cards = new List<Card>() { new Card(CardSuit.Club, CardType.Queen) };
            var action = new PlayerAction(PlayerActionType.ChangeTrump, new Card(CardSuit.Club, CardType.Queen), Announce.None);
            var round = new GameRound(new Player(), new Player(), PlayerPosition.FirstPlayer);
            var state = new MoreThanTwoCardsLeftRoundState(round);
            var context = new PlayerTurnContext(state, new Card(CardSuit.Club, CardType.Jack), 0);

            Assert.IsFalse(validator.IsValid(action, context, cards));
        }
コード例 #5
0
ファイル: UiPlayer.cs プロジェクト: NotDemons/NotDemonsRepo
        public void Action(PlayerAction playerAction)
        {
            if (!this.PlayerActionValidator.IsValid(playerAction, this.currentContext, this.Cards))
            {
                // Invalid player action
                return;
            }

            this.userAction = playerAction;
        }
コード例 #6
0
        public void FourtyAnnounce_ShouldBeValid()
        {
            var cards = new List<Card>() { new Card(CardSuit.Club, CardType.Queen), new Card(CardSuit.Club, CardType.King) };
            var announce = Announce.Fourty;
            var action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Club, CardType.Queen), announce);
            var round = new GameRound(new Player(), new Player(), PlayerPosition.FirstPlayer);
            var state = new MoreThanTwoCardsLeftRoundState(round);
            var context = new PlayerTurnContext(state, new Card(CardSuit.Club, CardType.Jack), 0);
            validator.IsValid(action, context, cards);

            Assert.AreEqual(Announce.Fourty, announce);
        }
コード例 #7
0
 public void Testing()
 {
     var action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Club, CardType.King), Announce.None);
     var first = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Club, CardType.Nine), Announce.None);
     var second = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Club, CardType.Ten), Announce.None);
     //// IPlayer first;
     //// IPlayer second;
     //// first.AddCard(new Card(CardSuit.Club, CardType.Nine));
     var firstToPlay = PlayerPosition.FirstPlayer;
     //// var gameRound = new GameRound(first, second, PlayerPosition.SecondPlayer);
     //// IGameRound gameRound;
     //// var context = new PlayerTurnContext(new StartRoundState(gameRound), new Card(CardSuit.Diamond, CardType.Ten), 24);
 }
コード例 #8
0
        public void AnnouncingAtFirstHandShouldBeValid()
        {
            MoreThanTwoCardsLeftRoundState stateOfMiddle = new MoreThanTwoCardsLeftRoundState(new GameRound(new Player(), new Player(), PlayerPosition.FirstPlayer));
            PlayerAction action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Heart, CardType.King), Announce.Twenty);
            PlayerTurnContext context = new PlayerTurnContext(stateOfMiddle, new Card(CardSuit.Spade, CardType.Jack), 6);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Heart, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Club, CardType.King),
                new Card(CardSuit.Club, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            validator.IsValid(action, context, cards);
            Assert.AreEqual(Announce.None, action.Announce);
        }
コード例 #9
0
        public bool IsValid(PlayerAction action, PlayerTurnContext context, ICollection<Card> playerCards)
        {
            if (context.State.CanAnnounce20Or40)
            {
                action.Announce = this.announceValidator.GetPossibleAnnounce(
                    playerCards,
                    action.Card,
                    context.TrumpCard,
                    context.IsFirstPlayerTurn);
            }

            if (action == null)
            {
                return false;
            }

            if (action.Type == PlayerActionType.PlayCard)
            {
                var canPlayCard = PlayCardActionValidator.CanPlayCard(
                    context.IsFirstPlayerTurn,
                    action.Card,
                    context.FirstPlayedCard,
                    context.TrumpCard,
                    playerCards,
                    context.State.ShouldObserveRules);
                return canPlayCard;
            }

            if (action.Type == PlayerActionType.ChangeTrump)
            {
                var canChangeTrump = ChangeTrumpActionValidator.CanChangeTrump(
                    context.IsFirstPlayerTurn,
                    context.State,
                    context.TrumpCard,
                    playerCards);
                return canChangeTrump;
            }

            // action.Type == PlayerActionType.CloseGame
            var canCloseGame = CloseGameActionValidator.CanCloseGame(context.IsFirstPlayerTurn, context.State);
            return canCloseGame;
        }
コード例 #10
0
        public void TestAnnounceFourty()
        {
            MoreThanTwoCardsLeftRoundState stateOfMiddle = new MoreThanTwoCardsLeftRoundState(new GameRound(new Player(), new Player(), PlayerPosition.FirstPlayer));

            PlayerAction action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Spade, CardType.King), Announce.Fourty);
            PlayerTurnContext context = new PlayerTurnContext(stateOfMiddle, new Card(CardSuit.Spade, CardType.Jack), 6);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Club, CardType.King),
                new Card(CardSuit.Club, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            // a card is played. Just to avoid context.AmITheFirstPlayer;
            context.FirstPlayedCard = new Card(CardSuit.Club, CardType.King);

            validator.IsValid(action, context, cards);
            Assert.AreEqual(Announce.Fourty, action.Announce);
        }
コード例 #11
0
 protected PlayerAction CloseGame()
 {
     return(PlayerAction.CloseGame());
 }
コード例 #12
0
 protected PlayerAction PlayCard(Card card)
 {
     this.Cards.Remove(card);
     return(PlayerAction.PlayCard(card));
 }
コード例 #13
0
 protected PlayerAction ChangeTrump(Card trumpCard)
 {
     this.Cards.Remove(Card.GetCard(trumpCard.Suit, CardType.Nine));
     this.Cards.Add(trumpCard);
     return(PlayerAction.ChangeTrump());
 }
コード例 #14
0
        public void TestSimpleValidAction()
        {
            // PlayerActionValidater validato2r = new PlayerActionValidater();
            MoreThanTwoCardsLeftRoundState middleState = new MoreThanTwoCardsLeftRoundState(new GameRound(new Player(), new Player(), PlayerPosition.FirstPlayer));

            PlayerAction action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Heart, CardType.King), Announce.None);
            PlayerTurnContext context = new PlayerTurnContext(middleState, new Card(CardSuit.Spade, CardType.Jack), 6);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Ten),
                new Card(CardSuit.Heart, CardType.King),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Club, CardType.King),
                new Card(CardSuit.Club, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            Assert.IsTrue(validator.IsValid(action, context, cards));
        }
コード例 #15
0
        public void ValidChangeOfTrumpCardShouldBeEvaluatedCorrectly()
        {
            MoreThanTwoCardsLeftRoundState midle = new MoreThanTwoCardsLeftRoundState(new GameRound(new Player(), new Player(), PlayerPosition.FirstPlayer));
            PlayerTurnContext context = new PlayerTurnContext(midle, new Card(CardSuit.Diamond, CardType.Ten), 6);
            PlayerAction action = new PlayerAction(PlayerActionType.ChangeTrump, new Card(CardSuit.Club, CardType.Nine), Announce.None);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Club, CardType.Ace),
                new Card(CardSuit.Club, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            Assert.IsTrue(validator.IsValid(action, context, cards));
        }
コード例 #16
0
        public void TestWrongChangeTrumpInTheBegining()
        {
            StartRoundState begin = new StartRoundState(new GameRound(new Player(), new Player(), PlayerPosition.FirstPlayer));

            PlayerTurnContext context = new PlayerTurnContext(begin, new Card(CardSuit.Diamond, CardType.Jack), 12);

            PlayerAction action = new PlayerAction(PlayerActionType.ChangeTrump, new Card(CardSuit.Club, CardType.Nine), Announce.None);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Club, CardType.Ace),
                new Card(CardSuit.Club, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            Assert.IsFalse(validator.IsValid(action, context, cards));
        }
コード例 #17
0
ファイル: ConsolePlayer.cs プロジェクト: darkyto/HQC-Course
        public override PlayerAction GetTurn(
            PlayerTurnContext context,
            IPlayerActionValidater actionValidater)
        {
            PrintGameInfo(context);
            while (true)
            {
                PlayerAction playerAction = null;

                Console.SetCursorPosition(0, this.row + 1);
                Console.Write(new string(' ', 79));
                Console.SetCursorPosition(0, this.row + 1);
                Console.Write("Turn? [1-{0}]=Card{1}",
                    this.cards.Count,
                    context.AmITheFirstPlayer ? "; [T]=Change trump;        [C]=Close: " : ": ");
                var userActionAsString = Console.ReadLine();
                if (string.IsNullOrWhiteSpace(userActionAsString))
                {
                    Console.WriteLine("Empty turn!                 ");
                    continue;
                }

                if (userActionAsString[0] >= '1'
                    && userActionAsString[0] <= '6')
                {
                    var cardIndex =
                        int.Parse(userActionAsString[0].ToString()) - 1;
                    if (cardIndex >= this.cards.Count)
                    {
                        Console.WriteLine("Invalid card!              ");
                        continue;
                    }

                    var card = this.cards[cardIndex];
                    var possibleAnnounce = Announce.None;

                    if (context.AmITheFirstPlayer)
                    {
                        possibleAnnounce = this.PossibleAnnounce(card, context.TrumpCard);
                        if (possibleAnnounce != Announce.None)
                        {
                            while (true)
                            {
                                Console.SetCursorPosition(0, this.row + 2);
                                Console.Write("Announce {0} [Y]/[N]?         ", possibleAnnounce.ToString());
                                var userInput = Console.ReadLine();
                                if (string.IsNullOrWhiteSpace(userInput))
                                {
                                    Console.WriteLine("Please enter [Y] or [N]         ");
                                    continue;
                                }

                                if (userInput[0] == 'N')
                                {
                                    possibleAnnounce = Announce.None;
                                }
                                else if (userInput[0] == 'Y')
                                {
                                    break;
                                }
                                else
                                {
                                    Console.WriteLine("Please enter [Y] or [N]         ");
                                    continue;
                                }
                            }
                        }
                    }

                    playerAction =
                        new PlayerAction(
                            PlayerActionType.PlayCard,
                            card,
                            possibleAnnounce);
                }
                else if (userActionAsString[0] == 'T')
                {
                    playerAction =
                        new PlayerAction(
                            PlayerActionType.ChangeTrump,
                            null,
                            Announce.None);
                }
                else if (userActionAsString[0] == 'C')
                {
                    playerAction =
                        new PlayerAction(
                            PlayerActionType.CloseGame,
                            null,
                            Announce.None);
                }
                else
                {
                    Console.WriteLine("Invalid turn!                ");
                    continue;
                }

                if (actionValidater.IsValid(playerAction, context, this.cards))
                {
                    if (playerAction.Type == PlayerActionType.PlayCard)
                    {
                        this.cards.Remove(playerAction.Card);
                    }

                    if (playerAction.Type == PlayerActionType.ChangeTrump)
                    {
                        this.cards.Remove(new Card(context.TrumpCard.Suit, CardType.Nine));
                    }

                    this.PrintGameInfo(context);

                    return playerAction;
                }
                else
                {
                    Console.WriteLine("Invalid action!                  ");
                    continue;
                }
            }
        }
コード例 #18
0
        public void TestValidMoveWithTrumpCard()
        {
            // Using this state to enter in context.State.ShouldObserveRules.
            FinalRoundState endRound = new FinalRoundState();

            PlayerTurnContext context = new PlayerTurnContext(endRound, new Card(CardSuit.Spade, CardType.Jack), 0);

            // a card is played. Just to avoid context.AmITheFirstPlayer;
            context.FirstPlayedCard = new Card(CardSuit.Club, CardType.Nine);

            PlayerAction action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Spade, CardType.Nine), Announce.None);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Diamond, CardType.King),
                new Card(CardSuit.Spade, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            Assert.IsTrue(validator.IsValid(action, context, cards));
        }
コード例 #19
0
        public void InvalidPlayerCardWithoutTrumpShouldBeEvaluаtedCorrectly()
        {
            FinalRoundState finalState = new FinalRoundState();
            PlayerTurnContext context = new PlayerTurnContext(finalState, new Card(CardSuit.Diamond, CardType.Jack), 0);
            context.FirstPlayedCard = new Card(CardSuit.Club, CardType.Ten);
            PlayerAction action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Spade, CardType.Queen), Announce.Twenty);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Club, CardType.King),
                new Card(CardSuit.Spade, CardType.Nine),
                new Card(CardSuit.Spade, CardType.Nine)
            };

            Assert.IsFalse(validator.IsValid(action, context, cards));
        }
コード例 #20
0
        public void TestInvalidMoveCardWithLowerValueWhenHaveBigger()
        {
            FinalRoundState finalState = new FinalRoundState();

            PlayerTurnContext context = new PlayerTurnContext(finalState, new Card(CardSuit.Diamond, CardType.Jack), 0);

            context.FirstPlayedCard = new Card(CardSuit.Club, CardType.King);

            // You must play card with bigger value.
            PlayerAction action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Club, CardType.Nine), Announce.None);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Club, CardType.Ace),
                new Card(CardSuit.Club, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            Assert.IsFalse(validator.IsValid(action, context, cards));
        }
コード例 #21
0
ファイル: UiPlayer.cs プロジェクト: NotDemons/NotDemonsRepo
        public override PlayerAction GetTurn(PlayerTurnContext context)
        {
            this.iAmFirstThisTurn = context.IsFirstPlayerTurn;
            this.UpdateContextInfo(context);
            this.currentContext = context;
            while (this.userAction == null)
            {
                Task.Delay(50);
            }

            lock (this.userAction)
            {
                PlayerAction action;
                switch (this.userAction.Type)
                {
                    case PlayerActionType.PlayCard:
                        action = this.PlayCard(this.userAction.Card);
                        this.RedrawCards?.Invoke(this, this.Cards);
                        this.RedrawPlayerPlayedCard?.Invoke(this, this.userAction.Card);
                        break;
                    case PlayerActionType.ChangeTrump:
                        action = this.ChangeTrump(context.TrumpCard);
                        this.RedrawCards?.Invoke(this, this.Cards);
                        break;
                    case PlayerActionType.CloseGame:
                        action = this.CloseGame();
                        this.GameClosed?.Invoke(this, EventArgs.Empty);
                        break;
                    default:
                        throw new ArgumentOutOfRangeException(nameof(this.userAction.Type));
                }

                this.userAction = null;
                return action;
            }
        }
コード例 #22
0
        public void TestWithIncorrectTrumpCard()
        {
            FinalRoundState finalState = new FinalRoundState();

            PlayerTurnContext context = new PlayerTurnContext(finalState, new Card(CardSuit.Diamond, CardType.Jack), 0);

            context.FirstPlayedCard = new Card(CardSuit.Club, CardType.Ten);

            // You have a needed suit card but played trump. False -> Must play Club
            PlayerAction action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Diamond, CardType.Nine), Announce.None);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Club, CardType.King),
                new Card(CardSuit.Spade, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            Assert.IsFalse(validator.IsValid(action, context, cards));
        }
コード例 #23
0
        public void FourtyAnnounceWhenPlayerIsNotFirstShouldChangeAnnounceToNone()
        {
            var cards = new List<Card>() { new Card(CardSuit.Club, CardType.Queen), new Card(CardSuit.Club, CardType.King), new Card(CardSuit.Heart, CardType.Jack) };
            var announce = Announce.Fourty;
            var action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Heart, CardType.Jack), announce);
            var round = new GameRound(new Player(), new Player(), PlayerPosition.SecondPlayer);
            var state = new MoreThanTwoCardsLeftRoundState(round);
            var context = new PlayerTurnContext(state, new Card(CardSuit.Club, CardType.Jack), 0);
            this.validater.IsValid(action, context, cards);

            Assert.AreEqual(Announce.None, action.Announce);
        }
コード例 #24
0
        public void TestWrongChangeTrumpIfYouHaveNotNeededCard()
        {
            MoreThanTwoCardsLeftRoundState midle = new MoreThanTwoCardsLeftRoundState(new GameRound(new Player(), new Player(), PlayerPosition.FirstPlayer));

            PlayerTurnContext context = new PlayerTurnContext(midle, new Card(CardSuit.Diamond, CardType.Jack), 6);

            PlayerAction action = new PlayerAction(PlayerActionType.ChangeTrump, new Card(CardSuit.Club, CardType.Nine), Announce.None);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Club, CardType.Ace),
                new Card(CardSuit.Club, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Ace)
            };

            Assert.IsFalse(validator.IsValid(action, context, cards));
        }
コード例 #25
0
        public void TestOtherCardWhenNoHaveTrump()
        {
            FinalRoundState finalState = new FinalRoundState();

            PlayerTurnContext context = new PlayerTurnContext(finalState, new Card(CardSuit.Diamond, CardType.Jack), 0);

            context.FirstPlayedCard = new Card(CardSuit.Club, CardType.Ten);

            // Have a club, but played Spade. False. Must play Club
            PlayerAction action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Spade, CardType.Queen), Announce.Twenty);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Club, CardType.King),
                new Card(CardSuit.Spade, CardType.Nine),
                new Card(CardSuit.Spade, CardType.Nine)
            };

            Assert.IsFalse(validator.IsValid(action, context, cards));
        }
コード例 #26
0
        public void TestInvalidPlayedCard()
        {
            FinalRoundState endState = new FinalRoundState();

            PlayerTurnContext context = new PlayerTurnContext(endState, new Card(CardSuit.Spade, CardType.Jack), 0);

            context.FirstPlayedCard = new Card(CardSuit.Club, CardType.Ten);

            PlayerAction action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Heart, CardType.Queen), Announce.None);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Club, CardType.King),
                new Card(CardSuit.Spade, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            Assert.IsFalse(validator.IsValid(action, context, cards));
        }
コード例 #27
0
        public void PlayingWithCardThatIsNotInHandShouldBeInvalid()
        {
            MoreThanTwoCardsLeftRoundState middleState = new MoreThanTwoCardsLeftRoundState(new GameRound(new Player(), new Player(), PlayerPosition.FirstPlayer));
            PlayerAction action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Diamond, CardType.Ace), Announce.None);
            PlayerTurnContext context = new PlayerTurnContext(middleState, new Card(CardSuit.Spade, CardType.Jack), 6);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Ten),
                new Card(CardSuit.Heart, CardType.King),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Club, CardType.King),
                new Card(CardSuit.Club, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            Assert.IsFalse(validator.IsValid(action, context, cards));
        }
コード例 #28
0
        public void InvalidClosingGameShouldBeEvaluatedCorrectly()
        {
            StartRoundState begin = new StartRoundState(new GameRound(new Player(), new Player(), PlayerPosition.FirstPlayer));
            PlayerTurnContext context = new PlayerTurnContext(begin, new Card(CardSuit.Diamond, CardType.Jack), 12);
            PlayerAction action = new PlayerAction(PlayerActionType.CloseGame, new Card(CardSuit.Club, CardType.Nine), Announce.None);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Club, CardType.Ace),
                new Card(CardSuit.Club, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            Assert.IsFalse(validator.IsValid(action, context, cards));
        }
コード例 #29
0
        public void ValidActionWithTrumpCardShouldBeEvaluatedCorrectly()
        {
            FinalRoundState endRound = new FinalRoundState();
            PlayerTurnContext context = new PlayerTurnContext(endRound, new Card(CardSuit.Spade, CardType.Jack), 0);
            context.FirstPlayedCard = new Card(CardSuit.Club, CardType.Nine);
            PlayerAction action = new PlayerAction(PlayerActionType.PlayCard, new Card(CardSuit.Spade, CardType.Nine), Announce.None);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Diamond, CardType.King),
                new Card(CardSuit.Spade, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            Assert.IsTrue(validator.IsValid(action, context, cards));
        }
コード例 #30
0
        public bool IsValid(PlayerAction action, PlayerTurnContext context, IList<Card> playerCards)
        {
            if (context.AmITheFirstPlayer)
            {
                action.Announce = Announce.None;
            }

            if (action.Type == PlayerActionType.PlayCard)
            {
                if (!playerCards.Contains(action.Card))
                {
                    return false;
                }

                if (action.Announce != Announce.None)
                {
                    if (action.Card.Type != CardType.Queen
                        && action.Card.Type != CardType.King)
                    {
                        action.Announce = Announce.None;
                    }

                    // TODO: Check for another card
                }

                if (context.State.ShouldObserveRules)
                {
                    if (!context.AmITheFirstPlayer)
                    {
                        var firstCard = context.FirstPlayedCard;
                        var ourCard = action.Card;

                        if (firstCard.Suit != ourCard.Suit)
                        {
                            if (ourCard.Suit != context.TrumpCard.Suit)
                            {
                                var hasTrump = playerCards.Any(c => c.Suit == context.TrumpCard.Suit);
                                if (hasTrump)
                                {
                                    return false;
                                }
                            }
                        }
                        else
                        {
                            if (ourCard.GetValue() < firstCard.GetValue())
                            {
                                var hasBigger = playerCards.Any(c => c.GetValue() > firstCard.GetValue());
                                if (hasBigger)
                                {
                                    return false;
                                }
                            }
                        }
                    }
                }
            }

            if (action.Type == PlayerActionType.CloseGame && !(context.State is FinalRoundState))
            {
                if (!context.State.CanClose || !context.AmITheFirstPlayer)
                {
                    return false;
                }
            }

            if (action.Type == PlayerActionType.ChangeTrump)
            {
                if (!context.State.CanChangeTrump || !context.AmITheFirstPlayer)
                {
                    return false;
                }

                if (!playerCards.Contains(new Card(context.TrumpCard.Suit, CardType.Nine)))
                {
                    return false;
                }
            }

            return true;
        }
コード例 #31
0
        public void TestInvalidClosingGameInMiddleRound()
        {
            MoreThanTwoCardsLeftRoundState middle = new MoreThanTwoCardsLeftRoundState(new GameRound(new Player(), new Player(), PlayerPosition.FirstPlayer));

            PlayerTurnContext context = new PlayerTurnContext(middle, new Card(CardSuit.Diamond, CardType.Jack), 6);

            context.FirstPlayedCard = new Card(CardSuit.Club, CardType.King);

            // Cannot Close game because it's already played a card.
            PlayerAction action = new PlayerAction(PlayerActionType.CloseGame, new Card(CardSuit.Club, CardType.Nine), Announce.None);
            IList<Card> cards = new List<Card>()
            {
                new Card(CardSuit.Spade, CardType.Queen),
                new Card(CardSuit.Spade, CardType.King),
                new Card(CardSuit.Heart, CardType.Queen),
                new Card(CardSuit.Club, CardType.Ace),
                new Card(CardSuit.Club, CardType.Nine),
                new Card(CardSuit.Diamond, CardType.Nine)
            };

            Assert.IsFalse(validator.IsValid(action, context, cards));
        }