SmartPlayerOld aligned with the current version of the AI. Performance improvement.

Author: NikolayIT

Source/AI/Santase.AI.SmartPlayer/SmartPlayerOld.cs

@@ -12,9 +12,7 @@
     // Overall strategy can be based on the game score. When opponent is close to the winning the player should be riskier.
     internal class SmartPlayerOld : BasePlayer
     {
-        private readonly ICollection<Card> playedCards = new List<Card>();
-
-        private readonly OpponentSuitCardsProvider opponentSuitCardsProvider = new OpponentSuitCardsProvider();
+        private readonly CardTracker cardTracker = new CardTracker();
 
         public override string Name => "Smart Player Old";
 
@@ -23,50 +21,74 @@ public override PlayerAction GetTurn(PlayerTurnContext context)
             // When possible change the trump card as this is almost always a good move
             // Changing trump can be non-optimal when:
             // 1. Current player is planning to close the game and don't want to give additional points to his opponent
-            // 2. The player will close the game and you will give him additional points by giving him bigger trump card instead of 9
+            // 2. The other player will close the game and you will give him additional points by giving him bigger trump card instead of 9
             // 3. Want to confuse the opponent
             if (this.PlayerActionValidator.IsValid(PlayerAction.ChangeTrump(), context, this.Cards))
             {
+                this.cardTracker.ChangeTrumpCard(context.TrumpCard);
                 return this.ChangeTrump(context.TrumpCard);
             }
 
             if (this.CloseGame(context))
             {
+                GlobalStats.GamesClosedByPlayer++;
                 return this.CloseGame();
             }
 
             return this.ChooseCard(context);
         }
 
-        public override void EndRound()
+        public override void StartRound(ICollection<Card> cards, Card trumpCard, int myTotalPoints, int opponentTotalPoints)
         {
-            this.playedCards.Clear();
-            base.EndRound();
+            base.StartRound(cards, trumpCard, myTotalPoints, opponentTotalPoints);
+
+            this.cardTracker.Clear();
+            foreach (var card in cards)
+            {
+                this.cardTracker.UnknownCards.Remove(card);
+            }
+        }
+
+        public override void AddCard(Card card)
+        {
+            base.AddCard(card);
+            this.cardTracker.UnknownCards.Remove(card);
         }
 
         public override void EndTurn(PlayerTurnContext context)
         {
-            this.playedCards.Add(context.FirstPlayedCard);
-            this.playedCards.Add(context.SecondPlayedCard);
+            if (context.CardsLeftInDeck == 2)
+            {
+                this.cardTracker.UnknownCards.Add(context.TrumpCard);
+            }
+
+            this.cardTracker.CardPlayed(context.FirstPlayedCard);
+            this.cardTracker.CardPlayed(context.SecondPlayedCard);
         }
 
         // 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)
+            if (!this.PlayerActionValidator.IsValid(PlayerAction.CloseGame(), context, this.Cards))
             {
-                GlobalStats.GamesClosedByPlayer++;
+                return false;
+            }
+
+            if (this.Cards.Count(x => x.Suit == context.TrumpCard.Suit) == 5)
+            {
+                return true;
             }
 
-            return shouldCloseGame;
+            return false;
         }
 
         // TODO: Improve choosing best card to play
         private PlayerAction ChooseCard(PlayerTurnContext context)
         {
+            this.cardTracker.TrumpCardSaw(context.TrumpCard);
+
             var possibleCardsToPlay = this.PlayerActionValidator.GetPossibleCardsToPlay(context, this.Cards);
+
             return context.State.ShouldObserveRules
                        ? (context.IsFirstPlayerTurn
                               ? this.ChooseCardWhenPlayingFirstAndRulesApply(context, possibleCardsToPlay)
@@ -88,7 +110,7 @@ private PlayerAction ChooseCardWhenPlayingFirstAndRulesDoNotApply(
             }
 
             // If the player is close to the win => play trump card which will surely win the trick
-            var cardToWinTheGame = this.GetTrumpCardWhichWillSurelyWinTheGame(context.TrumpCard, context.FirstPlayerRoundPoints, possibleCardsToPlay);
+            var cardToWinTheGame = this.GetTrumpCardWhichWillSurelyWinTheGame(context.TrumpCard.Suit, context.FirstPlayerRoundPoints, possibleCardsToPlay);
             if (cardToWinTheGame != null)
             {
                 return this.PlayCard(cardToWinTheGame);
@@ -97,13 +119,7 @@ private PlayerAction ChooseCardWhenPlayingFirstAndRulesDoNotApply(
             // 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)
+                    .OrderBy(x => this.cardTracker.UnknownCards.Count(y => y.Suit == x.Suit))
                     .ThenBy(x => x.GetValue())
                     .FirstOrDefault();
             if (cardToPlay != null)
@@ -121,16 +137,10 @@ private PlayerAction ChooseCardWhenPlayingFirstAndRulesApply(
             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 opponentHasTrump = this.cardTracker.UnknownCards.Any(x => x.Suit == context.TrumpCard.Suit);
 
             var trumpCard = this.GetCardWhichWillSurelyWinTheTrick(
                 context.TrumpCard.Suit,
-                context.CardsLeftInDeck == 0 ? null : context.TrumpCard,
                 opponentHasTrump);
             if (trumpCard != null)
             {
@@ -141,7 +151,6 @@ private PlayerAction ChooseCardWhenPlayingFirstAndRulesApply(
             {
                 var possibleCard = this.GetCardWhichWillSurelyWinTheTrick(
                     suit,
-                    context.CardsLeftInDeck == 0 ? null : context.TrumpCard,
                     opponentHasTrump);
                 if (possibleCard != null)
                 {
@@ -208,13 +217,13 @@ private PlayerAction ChooseCardWhenPlayingSecondAndRulesDoNotApply(
                 }
 
                 if (possibleCardsToPlay.Contains(new Card(context.TrumpCard.Suit, CardType.Queen))
-                    && this.playedCards.Contains(new Card(context.TrumpCard.Suit, CardType.King)))
+                    && this.cardTracker.PlayedCards.Contains(new Card(context.TrumpCard.Suit, CardType.King)))
                 {
                     return this.PlayCard(new Card(context.TrumpCard.Suit, CardType.Queen));
                 }
 
                 if (possibleCardsToPlay.Contains(new Card(context.TrumpCard.Suit, CardType.King))
-                    && this.playedCards.Contains(new Card(context.TrumpCard.Suit, CardType.Queen)))
+                    && this.cardTracker.PlayedCards.Contains(new Card(context.TrumpCard.Suit, CardType.Queen)))
                 {
                     return this.PlayCard(new Card(context.TrumpCard.Suit, CardType.King));
                 }
@@ -266,16 +275,16 @@ private PlayerAction ChooseCardWhenPlayingSecondAndRulesApply(
         }
 
         private Card GetTrumpCardWhichWillSurelyWinTheGame(
-            Card trumpCard,
+            CardSuit trumpSuit,
             int playerRoundPoints,
             ICollection<Card> possibleCardsToPlay)
         {
             var opponentBiggestTrumpCard =
-                this.opponentSuitCardsProvider.GetOpponentCards(this.Cards, this.playedCards, trumpCard, trumpCard.Suit)
+                this.cardTracker.UnknownCards.Where(x => x.Suit == trumpSuit)
                     .OrderByDescending(x => x.GetValue())
                     .FirstOrDefault();
             var myBiggestTrumpCards =
-                possibleCardsToPlay.Where(x => x.Suit == trumpCard.Suit).OrderByDescending(x => x.GetValue());
+                possibleCardsToPlay.Where(x => x.Suit == trumpSuit).OrderByDescending(x => x.GetValue());
 
             var sumOfPoints = 0;
             foreach (var myTrumpCard in myBiggestTrumpCards)
@@ -294,7 +303,7 @@ private Card GetTrumpCardWhichWillSurelyWinTheGame(
             return null;
         }
 
-        private Card GetCardWhichWillSurelyWinTheTrick(CardSuit suit, Card trumpCard, bool opponentHasTrump)
+        private Card GetCardWhichWillSurelyWinTheTrick(CardSuit suit, bool opponentHasTrump)
         {
             var myBiggestCard =
                 this.Cards.Where(x => x.Suit == suit).OrderByDescending(x => x.GetValue()).FirstOrDefault();
@@ -304,7 +313,7 @@ private Card GetCardWhichWillSurelyWinTheTrick(CardSuit suit, Card trumpCard, bo
             }
 
             var opponentBiggestCard =
-                this.opponentSuitCardsProvider.GetOpponentCards(this.Cards, this.playedCards, trumpCard, suit)
+                this.cardTracker.UnknownCards.Where(x => x.Suit == suit)
                     .OrderByDescending(x => x.GetValue())
                     .FirstOrDefault();
 

Source/Santase.Logic/GameMechanics/RoundPlayerInfo.cs

@@ -11,7 +11,7 @@ public RoundPlayerInfo(IPlayer player)
         {
             this.Player = player;
             this.Cards = new CardCollection();
-            this.TrickCards = new List<Card>();
+            this.TrickCards = new CardCollection();
             this.Announces = new List<Announce>();
             this.GameCloser = false;
         }