public override PlayerAction GetTurn(PlayerTurnContext context) { var possibleCardsToPlay = this.PlayerActionValidator.GetPossibleCardsToPlay(context, this.Cards); var shuffledCards = possibleCardsToPlay.Shuffle(); var cardToPlay = shuffledCards.First(); return this.PlayCard(cardToPlay); }
private PlayerAction EndGameTurn(PlayerTurnContext context, ICardTracker tracker, ICollection<Card> myHand) { this.root = new Node(null, null, context.IsFirstPlayerTurn); if (context.IsFirstPlayerTurn && this.root.Children.Count == 0) { tracker.SetFinalRoundHands(myHand); var myCards = myHand.ToList(); EndgameAnalyzer.Compute(this.root, null, myCards, tracker.OpponentTookWith, context.SecondPlayerRoundPoints, context.FirstPlayerRoundPoints); } else if (this.root.Children.Count == 0) { tracker.SetFinalRoundHands(myHand); var myCards = myHand.ToList(); while (tracker.OpponentTookWith.Count < 6) { tracker.OpponentTookWith.Add(null); } EndgameAnalyzer.Compute(this.root, context.FirstPlayedCard, myCards, tracker.OpponentTookWith, context.FirstPlayerRoundPoints, context.SecondPlayerRoundPoints); } if (!context.IsFirstPlayerTurn) { this.root = this.root.Children.First(x => x.Card == context.FirstPlayedCard); } var card = this.root.Children.OrderByDescending(x => x.Wins / (decimal)x.Total).First().Card; return PlayerAction.PlayCard(card); }
public override PlayerAction GetTurn(PlayerTurnContext context) { //if (this.PlayerActionValidator.IsValid(PlayerAction.ChangeTrump(), context, this.Cards)) //{ // this.CardsNotInDeck.Add(context.TrumpCard); // this.CardsNotInDeck.RemoveWhere(c => c.Suit == context.TrumpCard.Suit && c.Type == CardType.Nine); // return this.ChangeTrump(context.TrumpCard); //} //foreach (var card in this.Cards) //{ // if (card.Type == CardType.King && // (this.AnnounceValidator.GetPossibleAnnounce(this.Cards, card, context.TrumpCard) == Announce.Forty || // this.AnnounceValidator.GetPossibleAnnounce(this.Cards, card, context.TrumpCard) == Announce.Twenty)) // { // this.Cards.Remove(card); // return this.PlayCard(card); // } //} var bestCard = this.GetCardToPlay(context); return this.PlayCard(bestCard); }
private float MaxHandValue(Card card, PlayerTurnContext context) { var suit = card.Suit; var value = card.GetValue(); var isTrump = context.TrumpCard.Suit == suit; var result = 0f; var cardsToTake = this.cardtracker .AllCards[suit] .Where(x => x.Key < value && (x.Value == CardTracerState.InOpponentHand || x.Value == CardTracerState.Unknown)) .ToList(); if (isTrump) { cardsToTake .AddRange(this.cardtracker .AllCards .Where(s => s.Key != suit) .SelectMany(c => c.Value) .Where(x => x.Value == CardTracerState.InOpponentHand || x.Value == CardTracerState.Unknown)); } var high = cardsToTake.Count > 0 ? cardsToTake.Max(x => x.Key) : 0; result += high; if (isTrump) { result += 10; } return result / (this.MaxTakeCases(value, suit) - cardsToTake.Count()); }
private float PointAndSuitCountParameter(Card card, PlayerTurnContext context, ICollection<Card> allowedCards) { var cardSuit = card.Suit; float cardValue = card.GetValue(); float coutOfSuitInHand = allowedCards.Count(x => x.Suit == cardSuit); return (11f - cardValue) * coutOfSuitInHand; }
public float CardScore(Card card, PlayerTurnContext context, ICollection<Card> allowedCards) { float result = 0f; result += this.PointAndSuitCountParameter(card, context, allowedCards); result -= PointAndSuitMultiplier * this.PointAndSuitCountParameter(card, context, allowedCards); return result; }
public void CloneShouldReturnDifferentReference() { var haveStateMock = new Mock<IStateManager>(); var state = new StartRoundState(haveStateMock.Object); var playerTurnContext = new PlayerTurnContext(state, new Card(CardSuit.Heart, CardType.Queen), 12, 0, 0); var clonedPlayerTurnContext = playerTurnContext.DeepClone(); Assert.AreNotSame(playerTurnContext, clonedPlayerTurnContext); }
public void CloneShouldReturnObjectOfTypePlayerTurnContext() { var haveStateMock = new Mock<IStateManager>(); var state = new TwoCardsLeftRoundState(haveStateMock.Object); var playerTurnContext = new PlayerTurnContext(state, new Card(CardSuit.Diamond, CardType.Ace), 2, 0, 0); var clonedPlayerTurnContext = playerTurnContext.DeepClone(); Assert.IsInstanceOf<PlayerTurnContext>(clonedPlayerTurnContext); }
public override void EndTurn(PlayerTurnContext context) { this.UpdateContextInfo(context); var playedCards = this.iAmFirstThisTurn ? new Tuple<Card, Card>(context.FirstPlayedCard, context.SecondPlayedCard) : new Tuple<Card, Card>(context.SecondPlayedCard, context.FirstPlayedCard); this.RedrawPlayedCards?.Invoke(this, playedCards); base.EndTurn(context); }
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)); }
private int NumberOfHandsCardCanTake(Card card, PlayerTurnContext context) { var count = this.cardTracker.AllCards[card.Suit] .Where(x => (x.Value == CardTracerState.InOpponentHand || x.Value == CardTracerState.Unknown) && x.Key < card.GetValue()) .Count(); return count; }
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)); }
public override void EndTurn(PlayerTurnContext context) { Console.SetCursorPosition(20, 9); Console.WriteLine($"{context.FirstPlayedCard} - {context.SecondPlayedCard} "); Thread.Sleep(3000); Console.SetCursorPosition(20, 9); Console.WriteLine($" "); }
private float BiggestGainParameter(Card card, PlayerTurnContext context, ICollection<Card> allowedCards) { var suit = card.Suit; float value = card.GetValue(); var allOfSuit = this.cardtracker.AllCards[suit]; var maxAvailableForTaking = allOfSuit.Where(x => x.Value != CardTracerState.TakenByOpponent || x.Value != CardTracerState.TakenByPlayer).Max(x => x.Key); return (value + maxAvailableForTaking) / BiggestGainDivisor; }
public GameAction(Card opponent, Card player, PlayerTurnContext context, ICardTracker cardTracker) { this.OpponetCard = opponent; this.PlayerCard = player; this.PlayerTakes = this.CheckIfPlayerTakes(opponent, player, context); this.HandValue = opponent.GetValue() + player.GetValue(); this.CardMaxWorth = this.CardMaxWorthCalculator(player, cardTracker); this.OpponentPoints = context.FirstPlayerRoundPoints; this.PlayerPoints = context.SecondPlayerRoundPoints; }
public override PlayerAction GetTurn(PlayerTurnContext context) { // When possible change the trump card as this is always a good move if (this.PlayerActionValidator.IsValid(PlayerAction.ChangeTrump(), context, this.Cards)) { return this.ChangeTrump(context.TrumpCard); } return base.GetTurn(context); }
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)); }
public ICollection<GameAction> GetPossibleTakeCard(PlayerTurnContext context, ICollection<Card> hand) { var actions = new List<GameAction>(); foreach (var item in hand) { actions.Add(new GameAction(context.FirstPlayedCard, item, context, this.cardTracker)); } return actions; }
// TODO: Improve close game decision private bool CloseGame(PlayerTurnContext context) { var shouldCloseGame = this.PlayerActionValidator.IsValid(PlayerAction.CloseGame(), context, this.Cards) && this.Cards.Count(x => x.Suit == context.TrumpCard.Suit) == 5; if (shouldCloseGame) { GlobalStats.GamesClosedByPlayer++; } return shouldCloseGame; }
public override PlayerAction GetTurn(PlayerTurnContext context) { this.logger.LogLine("--GetTurn; " + $"Trump: {context.TrumpCard}({context.CardsLeftInDeck}); " + $"State: {context.State.GetType().Name.Replace("RoundState", string.Empty)}; " + $"First: {context.FirstPlayedCard}({context.FirstPlayerAnnounce}); " + $"I am first: {context.IsFirstPlayerTurn}"); var action = base.GetTurn(context); this.logger.LogLine($"Playing {action}"); return action; }
public void AmITheFirstPlayerShouldReturnFalseWhenCardIsAlreadyPlayed() { var haveStateMock = new Mock<IStateManager>(); var playerTurnContext = new PlayerTurnContext( new FinalRoundState(haveStateMock.Object), new Card(CardSuit.Club, CardType.Ace), 0, 0, 0) { FirstPlayedCard = new Card(CardSuit.Diamond, CardType.Ten) }; Assert.IsFalse(playerTurnContext.IsFirstPlayerTurn); }
public void AmITheFirstPlayerShouldReturnTrueWhenCardIsNotPlayedYet() { var haveStateMock = new Mock<IStateManager>(); var playerTurnContext = new PlayerTurnContext( new FinalRoundState(haveStateMock.Object), new Card(CardSuit.Club, CardType.Ace), 0, 0, 0); Assert.IsTrue(playerTurnContext.IsFirstPlayerTurn); }
// TODO: Improve choosing best card to play private PlayerAction ChooseCard(PlayerTurnContext context) { var possibleCardsToPlay = this.PlayerActionValidator.GetPossibleCardsToPlay(context, this.Cards); return context.State.ShouldObserveRules ? (context.IsFirstPlayerTurn ? this.ChooseCardWhenPlayingFirstAndRulesApply(context, possibleCardsToPlay) : this.ChooseCardWhenPlayingSecondAndRulesApply(context, possibleCardsToPlay)) : (context.IsFirstPlayerTurn ? this.ChooseCardWhenPlayingFirstAndRulesDoNotApply(context, possibleCardsToPlay) : this.ChooseCardWhenPlayingSecondAndRulesDoNotApply(context, possibleCardsToPlay)); }
private PlayerAction ChooseCardWhenPlayingFirstAndRulesApply( PlayerTurnContext context, ICollection<Card> possibleCardsToPlay) { // Find card that will surely win the trick var opponentHasTrump = this.opponentSuitCardsProvider.GetOpponentCards( this.Cards, this.playedCards, context.CardsLeftInDeck == 0 ? null : context.TrumpCard, context.TrumpCard.Suit).Any(); var trumpCard = this.GetCardWhichWillSurelyWinTheTrick( context.TrumpCard.Suit, context.CardsLeftInDeck == 0 ? null : context.TrumpCard, opponentHasTrump); if (trumpCard != null) { return this.PlayCard(trumpCard); } foreach (CardSuit suit in Enum.GetValues(typeof(CardSuit))) { var possibleCard = this.GetCardWhichWillSurelyWinTheTrick( suit, context.CardsLeftInDeck == 0 ? null : context.TrumpCard, opponentHasTrump); if (possibleCard != null) { return this.PlayCard(possibleCard); } } // Announce 40 or 20 if possible var action = this.TryToAnnounce20Or40(context, possibleCardsToPlay); if (action != null) { return action; } // Smallest non-trump card var cardToPlay = possibleCardsToPlay.Where(x => x.Suit != context.TrumpCard.Suit) .OrderBy(x => x.GetValue()) .FirstOrDefault(); if (cardToPlay != null) { return this.PlayCard(cardToPlay); } // Smallest card cardToPlay = possibleCardsToPlay.OrderBy(x => x.GetValue()).FirstOrDefault(); return this.PlayCard(cardToPlay); }
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); }
public override PlayerAction GetTurn(PlayerTurnContext context) { var possibleCardsToPlay = this.PlayerActionValidator.GetPossibleCardsToPlay(context, this.Cards); var shuffledCards = possibleCardsToPlay.Shuffle(); var cardToPlay = shuffledCards.First(); // SecondPlayer == Opponent var opponentCardType = context.SecondPlayedCard.Type; var opponentCardSuit = context.SecondPlayedCard.Suit; return this.PlayCard(cardToPlay); }
public override PlayerAction GetTurn(PlayerTurnContext context) { this.logger.LogLine("--GetTurn; " + $"Trump: {context.TrumpCard}({context.CardsLeftInDeck}); " + $"State: {context.State.GetType().Name.Replace("RoundState", string.Empty)}; " + $"First: {context.FirstPlayedCard}({context.FirstPlayerAnnounce}); " + $"I am first: {context.IsFirstPlayerTurn}"); var action = base.GetTurn(context); this.logger.LogLine($"Playing {action}"); return(action); }
public override void EndTurn(PlayerTurnContext context) { if (context.FirstPlayedCard != null) { this.CardsNotInDeck.Add(context.FirstPlayedCard); } if (context.SecondPlayedCard != null) { this.CardsNotInDeck.Add(context.SecondPlayedCard); } }
public Card ChooseCardToPlay(PlayerTurnContext context, ICollection<Card> stalkerCards) { var trumpSuit = context.TrumpCard.Suit; var highestPrioritySuit = 0; var priorityValue = int.MaxValue; // Get priorities for all suits var suitsPriorities = this.GetPriorityForEachSuit(context); // Check which suits are available var availableSuits = new int[4]; foreach (var card in stalkerCards) { var suit = (int)card.Suit; availableSuits[suit]++; } for (var i = 0; i < suitsPriorities.Length; i++) { if ((int)trumpSuit == i || availableSuits[i] == 0) { continue; } if (suitsPriorities[i] < priorityValue) { highestPrioritySuit = i; priorityValue = suitsPriorities[i]; } } // Select the cards from the best suit var cardsFromBestSuit = stalkerCards.Where(card => card.Suit == (CardSuit)highestPrioritySuit).OrderBy(this.stalkerHelper.GetCardPriority).ToList(); var cardsFromTrump = stalkerCards.Where(card => card.Suit == trumpSuit).OrderBy(this.stalkerHelper.GetCardPriority).ToList(); if (!context.State.ShouldObserveRules) { // Take all nontrump cards without Queen and King waiting for announce cardsFromBestSuit = stalkerCards.Where(c => c.Suit != trumpSuit && !(this.stalkerHelper.GetCardPriority(c) == 1 && this.IsCardWaitingForAnnounce(c))).OrderBy(this.stalkerHelper.GetCardPriority).ToList(); } // Sort cards by its priority var cardsToChooseFrom = cardsFromBestSuit.Count != 0 ? cardsFromBestSuit : cardsFromTrump; if (!context.State.ShouldObserveRules) { // THIS NUMBER WILL AFFECT THE DECISION OF THE STALKER WHEN IN OPEN STATE return priorityValue > CardChooserConstants.OpenGamePriority ? cardsToChooseFrom.LastOrDefault() : cardsToChooseFrom.FirstOrDefault(); } // THIS NUMBER WILL AFFECT THE DECISION OF THE STALKER WHEN IN CLOSED STATE return priorityValue < CardChooserConstants.ClosedGamePriority ? cardsToChooseFrom.LastOrDefault() : cardsToChooseFrom.FirstOrDefault(); }
private PlayerAction ChooseCardWhenPlayingFirstAndRulesDoNotApply( PlayerTurnContext context, ICollection<Card> possibleCardsToPlay) { // Announce 40 or 20 if possible var action = this.TryToAnnounce20Or40(context, possibleCardsToPlay); if (action != null) { return action; } // If the player is close to the win => play trump card which will surely win the trick var opponentBiggestTrumpCard = this.opponentSuitCardsProvider.GetOpponentCards( this.Cards, this.playedCards, context.TrumpCard, context.TrumpCard.Suit).OrderByDescending(x => x.GetValue()).FirstOrDefault(); var myBiggestTrumpCard = possibleCardsToPlay.Where(x => x.Suit == context.TrumpCard.Suit) .OrderByDescending(x => x.GetValue()) .FirstOrDefault(); if (context.FirstPlayerRoundPoints >= 66 - myBiggestTrumpCard?.GetValue()) { if (opponentBiggestTrumpCard == null || myBiggestTrumpCard.GetValue() > opponentBiggestTrumpCard.GetValue()) { return this.PlayCard(myBiggestTrumpCard); } } // Smallest non-trump card from the shortest opponent suit var cardToPlay = possibleCardsToPlay.Where(x => x.Suit != context.TrumpCard.Suit) .OrderBy( x => this.opponentSuitCardsProvider.GetOpponentCards( this.Cards, this.playedCards, context.TrumpCard, x.Suit).Count) .ThenBy(x => x.GetValue()) .FirstOrDefault(); if (cardToPlay != null) { return this.PlayCard(cardToPlay); } // Should never happen cardToPlay = possibleCardsToPlay.OrderBy(x => x.GetValue()).FirstOrDefault(); return this.PlayCard(cardToPlay); }
public override PlayerAction GetTurn(PlayerTurnContext context) { // When possible change the trump card as this is always a good move if (this.PlayerActionValidator.IsValid(PlayerAction.ChangeTrump(), context, this.Cards)) { return this.ChangeTrump(context.TrumpCard); } var possibleCardsToPlay = this.PlayerActionValidator.GetPossibleCardsToPlay(context, this.Cards); var shuffledCards = possibleCardsToPlay.Shuffle(); var cardToPlay = shuffledCards.First(); return this.PlayCard(cardToPlay); }
public virtual PlayerAction GetTurn(PlayerTurnContext context) { return(this.Player.GetTurn(context)); }
public PlayerAction GetTurn(PlayerTurnContext context, IPlayerActionValidater actionValidator) { throw new NotImplementedException(); }
public void EndTurn(PlayerTurnContext context) { throw new NotImplementedException(); }
public abstract PlayerAction GetTurn( PlayerTurnContext context, IPlayerActionValidator actionValidater);
public virtual void EndTurn(PlayerTurnContext context) { }
public override void EndTurn(PlayerTurnContext context) { this.logger.LogLine( $"End of turn {context.FirstPlayedCard}({context.FirstPlayerAnnounce}) - {context.SecondPlayedCard}"); base.EndTurn(context); }
public abstract PlayerAction GetTurn(PlayerTurnContext context);
public virtual void EndTurn(PlayerTurnContext context) { this.Player.EndTurn(context); }