Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[Sparafucile]

Hey guys.  Here's a game I played last night:

Butcher, Great hall, Horn of Plenty, Horse Traders, Minion, Pawn, Remake, Soothsay, Stonemason, Swindler

We disagreed on the opening.  Horse traders into minion, or Remake to thin the deck.  We both agreed we wanted lots of soothsayer action.   So I wrote up a strategy to simulate roughly what we did.  Can you guess which simulation does better vs big money?  Which simulator wins head to head?   Have a good idea of how you would have played this set of cards?  Let me know what your build was, and I may code it up for you.

Spoiler:


89.4% win for HorseTraderSoothsayerMinionGreatHall
8.8% win for BigMoney
1.8% there is a tie.

82.3% win for RemakeSoothsayer
17% win for BigMoney
0.7% there is a tie.

44.6% win for RemakeSoothsayer
53.3% win for HorseTraderSoothsayerMinionGreatHall
2.1% there is a tie.


Here's the Horse traders into minion variant:

Code: [Select]


            class MyPlayerAction
                : PlayerAction
            {
                 ...

                public override PlayerActionChoice ChooseBetween(GameState gameState, IsValidChoice acceptableChoice)
                {
                    if (gameState.CurrentCardBeingPlayed.Is<CardTypes.Minion>())
                    {
                        if (CountInHand<CardTypes.Minion>(gameState) >= 2)
                            return PlayerActionChoice.PlusCoin;

                        if (HasCardInHand<CardTypes.Butcher>(gameState) && HasCardInHand<CardTypes.Gold>(gameState))
                            return PlayerActionChoice.PlusCoin;

                        if(gameState.Self.ExpectedCoinValueAtEndOfTurn + CountInHand<CardTypes.Minion>(gameState) * 2 >= 6)
                            return PlayerActionChoice.PlusCoin;

                        if (HasCardInHand<CardTypes.Soothsayer>(gameState))
                        {                           
                            return PlayerActionChoice.PlusCoin;                           
                        }

                        return PlayerActionChoice.Discard;
                    }
               
                    return base.ChooseBetween(gameState, acceptableChoice);
                }
            }

            private static CardPickByPriority PurchaseOrder(bool shouldButcher)
            {
                return new CardPickByPriority(
                           CardAcceptance.For<CardTypes.Province>    (CardAcceptance.AlwaysMatch, CardAcceptance.OverPayMaxAmount),
                           CardAcceptance.For<CardTypes.Duchy>       (gameState => CountOfPile<CardTypes.Province>(gameState) <= 6, CardAcceptance.OverPayMaxAmount),
                           CardAcceptance.For<CardTypes.Soothsayer>  (1),
                           CardAcceptance.For<CardTypes.Butcher>     (1, gameState => CountAllOwned<CardTypes.Minion>(gameState) >= 3),
                           CardAcceptance.For<CardTypes.Gold>        (gameState => CountAllOwned<CardTypes.Minion>(gameState) >= 3),                           
                           CardAcceptance.For<CardTypes.Minion>      (),
                           CardAcceptance.For<CardTypes.HorseTraders>(1),
                           CardAcceptance.For<CardTypes.Silver>      (1),
                           CardAcceptance.For<CardTypes.GreatHall>   (gameState => CountOfPile<CardTypes.GreatHall>(gameState) >= 1),
                           CardAcceptance.For<CardTypes.Estate>      (gameState => CountOfPile<CardTypes.Province>(gameState) <= 4),
                           CardAcceptance.For<CardTypes.Silver>      (),
                           CardAcceptance.For<CardTypes.Estate>      (gameState => CardBeingPlayedIs<CardTypes.Butcher>(gameState))
                           );
            }

            private static CardPickByPriority ActionOrder()
            {
                return new CardPickByPriority(
                           CardAcceptance.For<CardTypes.GreatHall>(),
                           CardAcceptance.For<CardTypes.Minion>(),
                           CardAcceptance.For<CardTypes.Butcher>(),
                           CardAcceptance.For<CardTypes.Soothsayer>(),
                           CardAcceptance.For<CardTypes.HorseTraders>());
            }

            private static CardPickByPriority TrashOrder()
            {
                return new CardPickByPriority(
                        CardAcceptance.For<CardTypes.Gold>(gameState => CardBeingPlayedIs<CardTypes.Butcher>(gameState)),
                        CardAcceptance.For<CardTypes.Soothsayer>(gameState => CardBeingPlayedIs<CardTypes.Butcher>(gameState)),
                        CardAcceptance.For<CardTypes.HorseTraders>(gameState => CardBeingPlayedIs<CardTypes.Butcher>(gameState)),
                        CardAcceptance.For<CardTypes.Curse>(),                       
                        CardAcceptance.For<CardTypes.Copper>(gameState => gameState.Self.ExpectedCoinValueAtEndOfTurn < 8),
                        CardAcceptance.For<CardTypes.Estate>());
            }




Here's the Remodel variant:

Code: [Select]

            private static CardPickByPriority PurchaseOrder()
            {
                return new CardPickByPriority(
                           CardAcceptance.For<CardTypes.Province>(),
                           CardAcceptance.For<CardTypes.Duchy>(gameState => CountOfPile<CardTypes.Province>(gameState) <= 4),
                           CardAcceptance.For<CardTypes.Soothsayer>(1),                                                     
                           CardAcceptance.For<CardTypes.Gold>(1),
                           CardAcceptance.For<CardTypes.Soothsayer>(2),
                           CardAcceptance.For<CardTypes.Gold>(),
                           CardAcceptance.For<CardTypes.Duchy>(gameState => CardBeingPlayedIs<CardTypes.Remake>(gameState)),
                           CardAcceptance.For<CardTypes.Remake>(1),
                           //CardAcceptance.For<CardTypes.Remake>(gameState => ((double)CountAllOwned(TrashOrderWithoutRemake(), gameState)) / gameState.Self.AllOwnedCards.Count > 0.4),
                           CardAcceptance.For<CardTypes.Estate>(gameState => CountOfPile<CardTypes.Province>(gameState) <= 2),
                           CardAcceptance.For<CardTypes.GreatHall>(gameState => CountAllOwned<CardTypes.Silver>(gameState) >= 2),
                           CardAcceptance.For<CardTypes.Silver>()
                           );
            }

            private static CardPickByPriority ActionOrder()
            {
                return new CardPickByPriority(
                           CardAcceptance.For<CardTypes.GreatHall>(),
                           CardAcceptance.For<CardTypes.Soothsayer>(),
                           CardAcceptance.For<CardTypes.Remake>(ShouldPlayRemake));
            }

            private static CardPickByPriority TrashOrder()
            {
                return new CardPickByPriority(
                        CardAcceptance.For<CardTypes.Curse>(),
                        CardAcceptance.For<CardTypes.Estate>(gameState => CountOfPile<CardTypes.Province>(gameState) > 2),
                        CardAcceptance.For<CardTypes.Remake>(),
                        CardAcceptance.For<CardTypes.Copper>());
            }

            private static CardPickByPriority TrashOrderWithoutRemake()
            {
                return new CardPickByPriority(
                        CardAcceptance.For<CardTypes.Curse>(),
                        CardAcceptance.For<CardTypes.Estate>(gameState => CountOfPile<CardTypes.Province>(gameState) > 2),                       
                        CardAcceptance.For<CardTypes.Copper>());
            }

            private static bool ShouldPlayRemake(GameState gameState)
            {               
                return CountInHandFrom(TrashOrderWithoutRemake(), gameState) >= 2;
            }