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);
}
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);
}
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());
}
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());
}
public static Card[] AllKingdomCards()
{
var result = new List <Card>();
foreach (Card card in AllCards())
{
if (GameConfigBuilder.IsKingdomCard(card))
{
result.Add(card);
}
}
return(result.ToArray());
}
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();
}
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;
}
public static GameConfig CreateFromWithPlayPositionsSwapped(GameConfig gameConfig)
{
var result = new GameConfigBuilder(gameConfig);
result.SwapPlayerOneAndTwo();
return result.ToGameConfig();
}
public static GameConfig Create(params Card[] cards)
{
var result = new GameConfigBuilder();
result.kingdomPiles = cards;
return result.ToGameConfig();
}
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;
}
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;
}
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);
}