Esempio n. 1
0
        public static GameConfig Create(params Card[] cards)
        {
            var result = new GameConfigBuilder();

            result.kingdomPiles = cards;
            return(result.ToGameConfig());
        }
        private static void ComparePlayers(int gameCount, CardCountPair[] startingCards, TestOutput testOutput)
        {
            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();
            builder.SetKingdomCards(player1, player2);
            if (startingCards != null)
                builder.SetStartingDeck(startingCards);

            var gameConfig = builder.ToGameConfig();

            testOutput.ComparePlayers(
                Strategies.BigMoneyWithCard.Player(Cards.Witch, cardCount: 2),
                Strategies.BigMoneyWithCard.Player(Cards.Witch, cardCount: 2),
                gameConfig,
                rotateWhoStartsFirst: true,
                numberOfGames: gameCount,
                createGameLog: new Dominion.Data.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);
        }
Esempio n. 3
0
        private static void ComparePlayers(int gameCount, CardCountPair[] startingCards)
        {
            var gameLogFactory = new GameLogFactory();

            var player1 = Strategies.BigMoneyWithCard.Player(Cards.Witch, 1, cardCount: 2);
            var player2 = Strategies.BigMoneyWithCard.Player(Cards.Witch, 2, 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, 1, cardCount: 2),
                Strategies.BigMoneyWithCard.Player(Cards.Witch, 2, cardCount: 2),
                gameConfig,
                firstPlayerAdvantage: true,
                numberOfGames: gameCount,
                createGameLog: new Program.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);
        }
Esempio n. 4
0
        public Dominion.GameConfig GetGameConfig()
        {
            Dominion.StartingCardSplit player1Split = this.player1Strategy.StartingCardSplit.Value;
            Dominion.StartingCardSplit player2Split = this.player2Strategy.StartingCardSplit.Value;
            Dominion.Card[]            kingdomCards = this.currentDeck.Cards.Where(c => c.cardShapedObject is Card).Select(c => (Card)c.cardShapedObject).ToArray();
            Dominion.Event[]           events       = this.eventCards.Cards.Where(c => c.cardShapedObject is Event).Select(c => (Event)c.cardShapedObject).ToArray();
            Dominion.Landmark[]        landmarks    = this.eventCards.Cards.Where(c => c.cardShapedObject is Landmark).Select(c => (Landmark)c.cardShapedObject).ToArray();
            Dominion.Project[]         projects     = this.eventCards.Cards.Where(c => c.cardShapedObject is Project).Select(c => (Project)c.cardShapedObject).ToArray();
            DominionCard baneCard = this.BaneCard.CurrentCards.FirstOrDefault();

            var builder = new Dominion.GameConfigBuilder();

            builder.SetKingdomPiles(kingdomCards);
            builder.SetEvents(events);
            builder.SetLandmarks(landmarks);
            builder.SetProjects(projects);
            if (baneCard != null)
            {
                builder.SetBaneCard((Card)baneCard.dominionCard);
            }

            builder.useColonyAndPlatinum = this.UseColonyPlatinum.Value;
            builder.useShelters          = this.UseShelters.Value;
            builder.SetCardSplitPerPlayer(new Dominion.StartingCardSplit[] { player1Split, player2Split });

            return(builder.ToGameConfig());
        }
Esempio n. 5
0
        public static GameConfig Create(StartingCardSplit split, params Card[] cards)
        {
            var result = new GameConfigBuilder();

            result.kingdomPiles = cards;
            result.CardSplit    = split;
            return(result.ToGameConfig());
        }
        public static GameConfig Create(params Card[] cards)
        {
            var result = new GameConfigBuilder();

            result.kingdomPiles.AddRange(cards);
            result.events    = new List <Event>();
            result.landmarks = new List <Landmark>();
            return(result.ToGameConfig());
        }
Esempio n. 7
0
        public static Card[] AllKingdomCards()
        {
            var result = new List <Card>();

            foreach (Card card in AllCards())
            {
                if (GameConfigBuilder.IsKingdomCard(card))
                {
                    result.Add(card);
                }
            }

            return(result.ToArray());
        }
Esempio n. 8
0
        public double ComparePlayers(
            PlayerAction player1,
            PlayerAction player2,
            bool useShelters          = false,
            bool useColonyAndPlatinum = false,
            StartingCardSplit split   = StartingCardSplit.Random,
            bool rotateWhoStartsFirst = true,
            IEnumerable <CardCountPair>[] startingDeckPerPlayer = null,
            bool shouldParallel         = true,
            bool showVerboseScore       = true,
            bool showCompactScore       = false,
            bool showDistribution       = false,
            bool createHtmlReport       = true,
            bool createRankingReport    = false,
            int numberOfGames           = 1000,
            int logGameCount            = 10,
            bool debugLogs              = false,
            CreateGameLog createGameLog = null)
        {
            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,
                       rotateWhoStartsFirst: rotateWhoStartsFirst,
                       shouldParallel: shouldParallel,
                       showVerboseScore: showVerboseScore,
                       showCompactScore: showCompactScore,
                       showDistribution: showDistribution,
                       createHtmlReport: createHtmlReport,
                       createRankingReport: createRankingReport,
                       logGameCount: logGameCount,
                       debugLogs: debugLogs,
                       numberOfGames: numberOfGames,
                       createGameLog: createGameLog));
        }
        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();
        }
Esempio n. 10
0
        static void Main()
        {
            using (var testOutput = new TestOutput())
            {
                var player1 = Strategies.BigMoney.Player();
                var player2 = Strategies.Miser.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);
            }
        }
        public double GetScoreVs(PlayerAction action, bool showReport = false)
        {
            var player1Action = this.ToPlayerAction();
            var player2Action = action;

            GameConfigBuilder builder = new GameConfigBuilder();
            builder.SetKingdomCards(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;
        }
Esempio n. 12
0
 public static GameConfig CreateFromWithPlayPositionsSwapped(GameConfig gameConfig)
 {
     var result = new GameConfigBuilder(gameConfig);
     result.SwapPlayerOneAndTwo();
     return result.ToGameConfig();
 }
Esempio n. 13
0
 public static GameConfig Create(params Card[] cards)
 {
     var result = new GameConfigBuilder();
     result.kingdomPiles = cards;
     return result.ToGameConfig();
 }
Esempio n. 14
0
 public static GameConfig Create(StartingCardSplit split, params Card[] cards)
 {
     var result = new GameConfigBuilder();
     result.kingdomPiles = cards;
     result.CardSplit = split;
     return result.ToGameConfig();
 }
        /*
         *  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),
                }
            });

            builder.SetKingdomCards(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);
        }
 public static GameConfig Create(params Card[] cards)
 {
     var result = new GameConfigBuilder();
     result.kingdomPiles.AddRange(cards);
     result.events = new List<Card>();
     return result.ToGameConfig();
 }
        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;
        }
Esempio n. 18
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);
                    builder.SetKingdomCards(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;
        }
Esempio n. 19
0
        public double ComparePlayers(
            PlayerAction player1,
            PlayerAction player2,
            bool useShelters = false,
            bool useColonyAndPlatinum = false,
            StartingCardSplit split = StartingCardSplit.Random,
            bool rotateWhoStartsFirst = true,
            IEnumerable<CardCountPair>[] startingDeckPerPlayer = null,
            bool shouldParallel = true,
            bool showVerboseScore = true,
            bool showCompactScore = false,
            bool showDistribution = false,
            bool createHtmlReport = true,
            bool createRankingReport = false,
            int numberOfGames = 1000,
            int logGameCount = 10,
            bool debugLogs = false,
            CreateGameLog createGameLog = null)
        {
            GameConfigBuilder builder = new GameConfigBuilder();
            builder.SetKingdomCards(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,
                rotateWhoStartsFirst: rotateWhoStartsFirst,
                shouldParallel: shouldParallel,
                showVerboseScore: showVerboseScore,
                showCompactScore: showCompactScore,
                showDistribution: showDistribution,
                createHtmlReport: createHtmlReport,
                createRankingReport: createRankingReport,
                logGameCount: logGameCount,
                debugLogs: debugLogs,
                numberOfGames: numberOfGames,
                createGameLog: createGameLog);
        }