Exemple #1
0
        static void Main()
        {
            using (var testOutput = new TestOutput())
            {
                StrategyDescription descr1 = StrategyDescription.GetDefaultStrategyDescription().AddCardToPurchaseOrder(Cards.YoungWitch).AddCardToPurchaseOrder(Cards.Sage);
                StrategyDescription descr2 = StrategyDescription.GetDefaultStrategyDescription().AddCardToPurchaseOrder(Cards.SeaHag).AddCardToPurchaseOrder(Cards.Sage);

                //var player1 = Strategies.BigMoneyWithCard.Player(Cards.TreasureTrove, cardCount:10);
                //var player2 = Strategies.BigMoneyWithCard.Player(Cards.Gold);

                var player1 = descr1.ToPlayerAction("young witch");
                var player2 = descr2.ToPlayerAction("sea hag");

                var builder = new GameConfigBuilder();
                builder.SetBaneCard(Cards.Sage);
                builder.CardSplit = StartingCardSplit.Split43;
                builder.SetKingdomCards(player1, player2);

                testOutput.ComparePlayers(
                    player1,
                    player2,
                    builder.ToGameConfig(),
                    rotateWhoStartsFirst: true,
                    createHtmlReport: true,
                    numberOfGames: 1000,
                    shouldParallel: false);
            }
        }
        private static void ComparePlayers(int gameCount, CardCountPair[] startingCards)
        {
            var gameLogFactory = new GameLogFactory();

            var player1 = Strategies.BigMoneyWithCard.Player(Cards.Witch, cardCount: 2);
            var player2 = Strategies.BigMoneyWithCard.Player(Cards.Witch, cardCount: 2);

            var builder = new GameConfigBuilder();

            PlayerAction.SetKingdomCards(builder, player1, player2);
            if (startingCards != null)
            {
                builder.SetStartingDeck(startingCards);
            }

            var gameConfig = builder.ToGameConfig();

            Program.ComparePlayers(
                Strategies.BigMoneyWithCard.Player(Cards.Witch, cardCount: 2),
                Strategies.BigMoneyWithCard.Player(Cards.Witch, cardCount: 2),
                gameConfig,
                firstPlayerAdvantage: true,
                numberOfGames: gameCount,
                createGameLog: new CreateGameLog(gameLogFactory.CreateGameLog));

            System.Console.WriteLine("Curses Split was Uneven {0}%", gameLogFactory.UnEvenSplitPercent);
            System.Console.WriteLine();
            System.Console.WriteLine("When the curses were not split, Player 1 won the curse split {0}/{1}", gameLogFactory.Player1WinPercent, gameLogFactory.Player2WinPercent);
        }
Exemple #3
0
        public double Compare(PickByPriorityDescription leftPurchaseOrder, PickByPriorityDescription rightPurchaseOrder)
        {
            //System.Console.WriteLine("Comparing: ");
            //left.Write(System.Console.Out);
            //System.Console.WriteLine("");
            //right.Write(System.Console.Out);
            //System.Console.WriteLine("");
            PlayerAction leftPlayer    = new PlayerAction("Player1", leftPurchaseOrder.ToCardPicker());
            PlayerAction rightPlayer   = new PlayerAction("Player2", rightPurchaseOrder.ToCardPicker());
            int          numberOfGames = 33;

            GameConfigBuilder builder = new GameConfigBuilder();

            PlayerAction.SetKingdomCards(builder, leftPlayer, rightPlayer);

            var gameConfig           = builder.ToGameConfig();
            var rotateWhoStartsFirst = true;

            var strategyComparison = new Dominion.Data.StrategyComparison(leftPlayer, rightPlayer, gameConfig, rotateWhoStartsFirst, numberOfGames);

            var results = strategyComparison.ComparePlayers(
                gameIndex => null,
                gameIndex => null,
                shouldParallel: false,
                gatherStats: false,
                createGameLog: null);

            return(results.WinDifference);
        }
Exemple #4
0
        internal StrategyComparisonResults GetResultsFor(ComparisonDescription descr)
        {
            StrategyComparisonResults result = null;

            if (!this.resultsCache.TryGetValue(descr, out result))
            {
                GameConfigBuilder builder       = new GameConfigBuilder();
                PlayerAction      playerAction1 = descr.Player1Action;
                PlayerAction      playerAction2 = descr.Player2Action;

                if (playerAction1 != null && playerAction2 != null)
                {
                    System.Console.WriteLine("Playing {0} vs {1}", playerAction1.PlayerName, playerAction2.PlayerName);
                    PlayerAction.SetKingdomCards(builder, new PlayerAction[] { playerAction1, playerAction2 });

                    var gameConfig = builder.ToGameConfig();

                    var strategyComparison = new StrategyComparison(playerAction1, playerAction2, gameConfig, rotateWhoStartsFirst: true, numberOfGames: 1000);
                    result = strategyComparison.ComparePlayers(
                        gameIndex => null,
                        gameIndex => null,
                        shouldParallel: true,
                        gatherStats: true);

                    this.resultsCache.Add(descr, result);
                }
                else
                {
                    this.resultsCache.Add(descr, null);
                }
            }

            return(result);
        }
Exemple #5
0
        public static double ComparePlayers(
            object player1OrString,
            object player2OrString,
            bool useShelters          = false,
            bool useColonyAndPlatinum = false,
            StartingCardSplit split   = StartingCardSplit.Random,
            bool firstPlayerAdvantage = false,
            IEnumerable <CardCountPair>[] startingDeckPerPlayer = null,
            bool shouldParallel         = true,
            bool showVerboseScore       = true,
            bool showCompactScore       = false,
            bool showDistribution       = false,
            bool createHtmlReport       = true,
            int numberOfGames           = 1000,
            int logGameCount            = 10,
            bool debugLogs              = false,
            CreateGameLog createGameLog = null)
        {
            PlayerAction player1 = strategyLoader.GetPlayerAction(player1OrString);
            PlayerAction player2 = strategyLoader.GetPlayerAction(player2OrString);

            GameConfigBuilder builder = new GameConfigBuilder();

            PlayerAction.SetKingdomCards(builder, player1, player2);

            builder.useColonyAndPlatinum = useColonyAndPlatinum;
            builder.useShelters          = useShelters;
            builder.CardSplit            = split;

            if (startingDeckPerPlayer != null)
            {
                builder.SetStartingDeckPerPlayer(startingDeckPerPlayer);
            }

            var gameConfig = builder.ToGameConfig();

            return(ComparePlayers(
                       player1,
                       player2,
                       gameConfig,
                       firstPlayerAdvantage: firstPlayerAdvantage,
                       shouldParallel: shouldParallel,
                       showVerboseScore: showVerboseScore,
                       showCompactScore: showCompactScore,
                       showDistribution: showDistribution,
                       createHtmlReport: createHtmlReport,
                       logGameCount: logGameCount,
                       debugLogs: debugLogs,
                       numberOfGames: numberOfGames,
                       createGameLog: createGameLog));
        }
Exemple #6
0
        static void Main()
        {
            using (var testOutput = new TestOutput())
            {
                var player1 = Strategies.GardensCounterPlay.Player(Cards.Monument);
                var player2 = Strategies.GardensWorkshop.Player();

                var builder = new GameConfigBuilder();
                builder.CardSplit = StartingCardSplit.Split43;
                builder.SetKingdomCards(player1, player2);

                testOutput.ComparePlayers(
                    new PlayerAction[] { player1, player2 },
                    builder.ToGameConfig(),
                    rotateWhoStartsFirst: true,
                    createHtmlReport: true,
                    numberOfGames: 1000,
                    shouldParallel: false);
            }
        }
Exemple #7
0
        static void Main()
        {
            using (var testOutput = new TestOutput())
            {
                var player1 = Strategies.BigMoneyWithCard.Player(Cards.Amulet, cardCount: 1);
                var player2 = Strategies.BigMoneyWithCard.Player(Cards.Gold);

                var builder = new GameConfigBuilder();
                builder.CardSplit = StartingCardSplit.Split43;

                PlayerAction.SetKingdomCards(builder, player1, player2);
                testOutput.ComparePlayers(
                    player1,
                    player2,
                    builder.ToGameConfig(),
                    rotateWhoStartsFirst: true,
                    createHtmlReport: true,
                    numberOfGames: 1000,
                    shouldParallel: false);
            }
        }
        public object GetResponse(WebService service)
        {
            var playerActions = new List <PlayerAction>();
            var player1       = this.Player1Action;

            if (player1 != null)
            {
                playerActions.Add(player1);
            }
            var player2 = this.Player2Action;

            if (player2 != null)
            {
                playerActions.Add(player2);
            }

            var builder = new GameConfigBuilder();

            builder.SetKingdomCards(playerActions.ToArray());
            return(builder.ToGameConfig().kingdomPiles.OrderBy(card => card.DefaultCoinCost).Select(card => GetCardImageName(card)).ToArray());
        }
Exemple #9
0
        public static StrategyComparisonResults Compare(
            PlayerAction player1,
            PlayerAction player2,
            int numberOfGames         = 100,
            bool rotateWhoStartsFirst = false,
            bool shouldParalell       = false,
            bool gatherStats          = true)
        {
            GameConfigBuilder builder = new GameConfigBuilder();

            builder.SetKingdomCards(player1, player2);

            var gameConfig         = builder.ToGameConfig();
            var strategyComparison = new Dominion.Data.StrategyComparison(player1, player2, gameConfig, rotateWhoStartsFirst, numberOfGames);

            var results = strategyComparison.ComparePlayers(
                gameIndex => null,
                gameIndex => null,
                shouldParallel: shouldParalell,
                gatherStats: gatherStats,
                createGameLog: null);

            return(results);
        }
Exemple #10
0
        public double GetScoreVs(PlayerAction action, bool showReport = false)
        {
            var player1Action = this.ToPlayerAction();
            var player2Action = action;

            GameConfigBuilder builder = new GameConfigBuilder();

            PlayerAction.SetKingdomCards(builder, player1Action, player1Action);

            var gameConfig           = builder.ToGameConfig();
            var rotateWhoStartsFirst = true;
            var numberOfGames        = 100;

            var strategyComparison = new Dominion.Data.StrategyComparison(player1Action, player2Action, gameConfig, rotateWhoStartsFirst, numberOfGames);

            var results = strategyComparison.ComparePlayers(
                gameIndex => null,
                gameIndex => null,
                shouldParallel: true,
                gatherStats: false,
                createGameLog: null);

            return(results.WinDifference);
        }
Exemple #11
0
        /*
         *  This code answers the following question.   It's player 1's turn.   No provinces have been bought yet - but he's down
         *  scrying pools (lost the split 4/6) and has a more non actions in his deck than the opponent.   Opponenent can
         *  also double province on his turn.  If player1 starts a double province buy war, he will probably Not chain first and lose.
         *  So intead, though he can afford 2 provinces, opts for 1 province, 2 estates and 2 crossroads.
         *  This leaves the deck composition as described below, with scrying pool and festival pile already empty.
         *  There are remaining 6 estates ending, the plan is on the next turn to chain enough of the deck to buy all 6 estates
         *  and 3 pile out the game.   What is the probability of this happening?  (need to draw all 5 festivals and 2 additional coin)
         * */
        public static void Run()
        {
            var player1 = ScryingPoolAndCrossroads.Player();
            var player2 = Strategies.BigMoney.Player();

            var builder = new GameConfigBuilder();

            builder.CardSplit = StartingCardSplit.Random;

            builder.SetStartingDeckPerPlayer(
                new Dominion.CardCountPair[][]
            {
                new Dominion.CardCountPair[]        // Player1
                {
                    new Dominion.CardCountPair(Cards.Estate, 5),
                    new Dominion.CardCountPair(Cards.Province, 1),
                    new Dominion.CardCountPair(Cards.Festival, 5),
                    new Dominion.CardCountPair(Cards.Silver, 2),
                    new Dominion.CardCountPair(Cards.Copper, 2),
                    new Dominion.CardCountPair(Cards.CrossRoads, 3),
                    new Dominion.CardCountPair(Cards.ScryingPool, 4),
                    new Dominion.CardCountPair(Cards.WanderingMinstrel, 1),
                    new Dominion.CardCountPair(Cards.Remake, 1),
                },
                new Dominion.CardCountPair[]        // Player2
                {
                    new Dominion.CardCountPair(Cards.Estate, 3),
                    new Dominion.CardCountPair(Cards.Copper, 7),
                }
            });

            PlayerAction.SetKingdomCards(builder, player1, player2);
            GameConfig gameConfig = builder.ToGameConfig();

            var playerActions = new PlayerAction[] { player1, player2 };

            int countWin  = 0;
            int countGame = 1000;

            for (int i = 0; i < countGame; ++i)
            {
                using (var indentedTextOutput = TestOutput.GetGameLogWriterForIteration(playerActions, i))
                {
                    var gameLog = new HumanReadableGameLog(indentedTextOutput);
                    using (Game game = new Game(new Random(i), gameConfig, gameLog))
                    {
                        GameState gameState = new GameState(playerActions, new int[] { 0, 1 }, game);

                        PlayerState currentPlayer = gameState.players[0];

                        gameLog.BeginRound(currentPlayer);
                        gameState.PlayTurn(currentPlayer);
                        // 11 = 3 starting estates plus all 8 estates in the pile
                        if (currentPlayer.AllOwnedCards.CountOf(Cards.Estate) == 11)
                        {
                            countWin++;
                            System.Console.WriteLine("Won Game {0}", i);
                        }
                    }
                }
            }

            System.Console.WriteLine("{1}% win for {0}", player1.PlayerName, (double)countWin / countGame * 100);
        }