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);
}
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);
}
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);
}
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));
}
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);
}
}
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());
}
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);
}
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);
}
/*
* 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);
}