public double ComparePlayers(
PlayerAction player1,
PlayerAction player2,
GameConfig gameConfig,
bool rotateWhoStartsFirst = true,
bool shouldParallel = true,
bool showVerboseScore = true,
bool showCompactScore = false,
bool showDistribution = false,
bool createHtmlReport = true,
bool createRankingReport = false,
int numberOfGames = 1000,
int logGameCount = 100,
bool debugLogs = false,
CreateGameLog createGameLog = null)
{
return(ComparePlayers(new PlayerAction[] { player1, player2 },
gameConfig,
rotateWhoStartsFirst,
shouldParallel,
showVerboseScore,
showCompactScore,
showDistribution,
createHtmlReport,
createRankingReport,
numberOfGames,
logGameCount,
debugLogs,
createGameLog));
}
public double ComparePlayers(
PlayerAction[] playerActions,
GameConfig gameConfig,
bool rotateWhoStartsFirst = true,
bool shouldParallel = true,
bool showVerboseScore = true,
bool showCompactScore = false,
bool showDistribution = false,
bool createHtmlReport = true,
bool createRankingReport = false,
int numberOfGames = 1000,
int logGameCount = 100,
bool debugLogs = false,
CreateGameLog createGameLog = null)
{
var strategyComparison = new StrategyComparison(playerActions, gameConfig, rotateWhoStartsFirst, numberOfGames);
var results = strategyComparison.ComparePlayers(
gameIndex => gameIndex < logGameCount ? GetGameLogWriterForIteration(playerActions, gameIndex) : null,
gameIndex => debugLogs && gameIndex < logGameCount ? GetDebugLogWriterForIteration(playerActions, gameIndex) : null,
shouldParallel: shouldParallel,
gatherStats: createHtmlReport,
createGameLog: createGameLog);
if (showVerboseScore)
{
results.WriteVerboseScore(System.Console.Out);
}
if (showCompactScore)
{
results.WriteCompactScore(System.Console.Out);
}
if (showDistribution)
{
results.ShowDistribution(System.Console.Out);
}
if (createHtmlReport)
{
deferredHtmlGenerator.AddResults(results, GetOutputFilename);
}
if (createRankingReport)
{
this.resultRanker.AddResult(playerActions[0].PlayerName, playerActions[1].PlayerName, results.WinDifference);
}
return(results.WinDifference);
}
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));
}
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));
}
public double ComparePlayers(
PlayerAction[] playerActions,
GameConfig gameConfig,
bool rotateWhoStartsFirst = true,
bool shouldParallel = true,
bool showVerboseScore = true,
bool showCompactScore = false,
bool showDistribution = false,
bool createHtmlReport = true,
bool createRankingReport = false,
int numberOfGames = 1000,
int logGameCount = 100,
bool debugLogs = false,
CreateGameLog createGameLog = null)
{
var strategyComparison = new StrategyComparison(playerActions, gameConfig, rotateWhoStartsFirst, numberOfGames);
var results = strategyComparison.ComparePlayers(
gameIndex => gameIndex < logGameCount ? GetGameLogWriterForIteration(playerActions, gameIndex) : null,
gameIndex => debugLogs && gameIndex < logGameCount ? GetDebugLogWriterForIteration(playerActions, gameIndex) : null,
shouldParallel: shouldParallel,
gatherStats: createHtmlReport,
createGameLog: createGameLog);
if (showVerboseScore)
{
results.WriteVerboseScore(System.Console.Out);
}
if (showCompactScore)
{
results.WriteCompactScore(System.Console.Out);
}
if (showDistribution)
{
results.ShowDistribution(System.Console.Out);
}
if (createHtmlReport)
{
deferredHtmlGenerator.AddResults(results, GetOutputFilename);
}
if (createRankingReport)
{
this.resultRanker.AddResult(playerActions[0].PlayerName, playerActions[1].PlayerName, results.WinDifference);
}
return results.WinDifference;
}
public double ComparePlayers(
string player1,
string player2,
bool useShelters = false,
bool useColonyAndPlatinum = false,
StartingCardSplit split = StartingCardSplit.Random,
bool rotateWhoStartsFirst = false,
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)
{
return(ComparePlayers(
BuiltInStrategies.StrategyLoader.PlayerFromString(player1),
BuiltInStrategies.StrategyLoader.PlayerFromString(player2),
useShelters,
useColonyAndPlatinum,
split,
rotateWhoStartsFirst,
startingDeckPerPlayer,
shouldParallel,
showVerboseScore,
showCompactScore,
showDistribution,
createHtmlReport,
createRankingReport,
numberOfGames,
logGameCount,
debugLogs,
createGameLog));
}
public StrategyComparisonResults ComparePlayers(
GetLogForGame getHumanReadableLogWriter = null,
GetLogForGame getDebugLogWriter = null,
bool shouldParallel = true,
bool gatherStats = true,
CreateGameLog createGameLog = null,
int randomSeed = 0)
{
PlayerAction player1 = playerActions[0];
PlayerAction player2 = playerActions[1];
var result = new StrategyComparisonResults(this, gatherStats);
Action <int> loopBody = delegate(int gameCount)
{
System.Threading.Interlocked.Increment(ref totalGameCount);
using (IndentedTextWriter textWriter = getHumanReadableLogWriter != null ? getHumanReadableLogWriter(gameCount) : null)
using (IndentedTextWriter debugWriter = getDebugLogWriter != null ? getDebugLogWriter(gameCount) : null)
{
var gameLogs = new List <IGameLog>();
if (gatherStats)
{
gameLogs.Add(result.statGatherer);
}
if (createGameLog != null)
{
gameLogs.Add(createGameLog());
}
if (textWriter != null)
{
var humanReadableGameLog = new HumanReadableGameLog(textWriter);
gameLogs.Add(humanReadableGameLog);
var gainSequenceGameLog = new GainSequenceGameLog(textWriter);
gameLogs.Add(gainSequenceGameLog);
}
if (debugWriter != null)
{
var debugLog = new DebugGameLog(debugWriter);
gameLogs.Add(debugLog);
var gainSequenceGameLog = new GainSequenceGameLog(debugWriter);
gameLogs.Add(gainSequenceGameLog);
}
var gameLogMultiplexer = new GameLogMultiplexer(gameLogs.ToArray());
// swap order every game if needed
int[] playedPositions = this.GetPlayerOrderForGameNumber(gameCount);
Random random = new Random(gameCount + randomSeed);
using (Game game = new Game(random, gameConfig, gameLogMultiplexer))
{
GameState gameState = new GameState(
playerActions,
playedPositions,
game);
gameState.PlayGameToEnd();
PlayerState[] winners = gameState.WinningPlayers;
int player1Score = gameState.players.OriginalPlayerOrder[playedPositions[0]].TotalScore();
int player2Score = gameState.players.OriginalPlayerOrder[playedPositions[1]].TotalScore();
int scoreDifference = player2Score - player1Score;
lock (result)
{
result.pointSpreadHistogramData.AddOneToBucket(scoreDifference);
result.gameEndOnTurnHistogramData.AddOneToBucket(gameState.players.CurrentPlayer.TurnNumber);
result.maxTurnNumber = Math.Max(gameState.players.CurrentPlayer.TurnNumber, result.maxTurnNumber);
if (winners.Length == 1)
{
int winningPlayerIndex = winners[0].Actions == player1 ? 0 : 1;
result.winnerCount[winningPlayerIndex]++;
}
else
{
result.tieCount++;
}
}
}
}
};
if (shouldParallel)
{
Parallel.ForEach(Enumerable.Range(0, numberOfGames), loopBody);
}
else
{
for (int gameCount = 0; gameCount < numberOfGames; ++gameCount)
{
loopBody(gameCount);
}
}
result.gameEndOnTurnHistogramData.InitializeAllBucketsUpTo(result.maxTurnNumber);
return(result);
}
public StrategyComparisonResults ComparePlayers(
GetLogForGame getHumanReadableLogWriter = null,
GetLogForGame getDebugLogWriter = null,
bool shouldParallel = true,
bool gatherStats = true,
CreateGameLog createGameLog = null,
int randomSeed = 0)
{
PlayerAction player1 = playerActions[0];
PlayerAction player2 = playerActions[1];
var result = new StrategyComparisonResults(this, gatherStats);
Action<int> loopBody = delegate(int gameCount)
{
System.Threading.Interlocked.Increment(ref totalGameCount);
using (IndentedTextWriter textWriter = getHumanReadableLogWriter != null ? getHumanReadableLogWriter(gameCount) : null)
using (IndentedTextWriter debugWriter = getDebugLogWriter != null ? getDebugLogWriter(gameCount) : null)
{
var gameLogs = new List<IGameLog>();
if (gatherStats)
{
gameLogs.Add(result.statGatherer);
}
if (createGameLog != null)
{
gameLogs.Add(createGameLog());
}
if (textWriter != null)
{
var humanReadableGameLog = new HumanReadableGameLog(textWriter);
gameLogs.Add(humanReadableGameLog);
var gainSequenceGameLog = new GainSequenceGameLog(textWriter);
gameLogs.Add(gainSequenceGameLog);
}
if (debugWriter != null)
{
var debugLog = new DebugGameLog(debugWriter);
gameLogs.Add(debugLog);
var gainSequenceGameLog = new GainSequenceGameLog(debugWriter);
gameLogs.Add(gainSequenceGameLog);
}
var gameLogMultiplexer = new GameLogMultiplexer(gameLogs.ToArray());
// swap order every game if needed
int[] playedPositions = this.GetPlayerOrderForGameNumber(gameCount);
Random random = new Random(gameCount + randomSeed);
using (Game game = new Game(random, gameConfig, gameLogMultiplexer))
{
GameState gameState = new GameState(
playerActions,
playedPositions,
game);
gameState.PlayGameToEnd();
PlayerState[] winners = gameState.WinningPlayers;
int player1Score = gameState.players.OriginalPlayerOrder[playedPositions[0]].TotalScore();
int player2Score = gameState.players.OriginalPlayerOrder[playedPositions[1]].TotalScore();
int scoreDifference = player2Score - player1Score;
lock (result)
{
result.pointSpreadHistogramData.AddOneToBucket(scoreDifference);
result.gameEndOnTurnHistogramData.AddOneToBucket(gameState.players.CurrentPlayer.TurnNumber);
result.maxTurnNumber = Math.Max(gameState.players.CurrentPlayer.TurnNumber, result.maxTurnNumber);
if (winners.Length == 1)
{
int winningPlayerIndex = winners[0].Actions == player1 ? 0 : 1;
result.winnerCount[winningPlayerIndex]++;
}
else
{
result.tieCount++;
}
}
}
}
};
if (shouldParallel)
{
Parallel.ForEach(Enumerable.Range(0, numberOfGames), loopBody);
}
else
{
for (int gameCount = 0; gameCount < numberOfGames; ++gameCount)
loopBody(gameCount);
}
result.gameEndOnTurnHistogramData.InitializeAllBucketsUpTo(result.maxTurnNumber);
return result;
}
public static double ComparePlayers(
object player1OrString,
object player2OrString,
GameConfig gameConfig,
bool firstPlayerAdvantage = false,
bool shouldParallel = true,
bool showVerboseScore = true,
bool showCompactScore = false,
bool showDistribution = false,
bool createHtmlReport = true,
int numberOfGames = 1000,
int logGameCount = 100,
bool debugLogs = false,
CreateGameLog createGameLog = null)
{
PlayerAction player1 = strategyLoader.GetPlayerAction(player1OrString);
PlayerAction player2 = strategyLoader.GetPlayerAction(player2OrString);
var strategyComparison = new StrategyComparison(player1, player2, gameConfig, firstPlayerAdvantage, numberOfGames);
var results = strategyComparison.ComparePlayers(
gameIndex => gameIndex < logGameCount ? GetGameLogWriterForIteration(player1, player2, gameIndex) : null,
gameIndex => debugLogs && gameIndex < logGameCount ? GetDebugLogWriterForIteration(player1, player2, gameIndex) : null,
shouldParallel: shouldParallel,
gatherStats: createHtmlReport,
createGameLog: createGameLog);
if (showVerboseScore)
{
results.WriteVerboseScore(System.Console.Out);
}
if (showCompactScore)
{
results.WriteCompactScore(System.Console.Out);
}
if (showDistribution)
{
System.Console.WriteLine("");
System.Console.WriteLine("Player 1 Score Delta distribution");
System.Console.WriteLine("=================================");
results.pointSpreadHistogramData.WriteBuckets(System.Console.Out);
}
if (createHtmlReport)
{
System.Threading.Interlocked.Increment(ref outstandingTasks);
// write out HTML report summary
var thread = new System.Threading.Thread(delegate()
{
var generator = new HtmlReportGenerator(results);
generator.CreateHtmlReport(GetOuputFilename(player1.PlayerName + " VS " + player2.PlayerName + ".html"));
System.Threading.Interlocked.Decrement(ref outstandingTasks);
});
thread.Start();
}
return(results.WinDifference);
}
public double ComparePlayers(
string player1,
string player2,
bool useShelters = false,
bool useColonyAndPlatinum = false,
StartingCardSplit split = StartingCardSplit.Random,
bool rotateWhoStartsFirst = false,
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)
{
return ComparePlayers(
BuiltInStrategies.StrategyLoader.PlayerFromString(player1),
BuiltInStrategies.StrategyLoader.PlayerFromString(player2),
useShelters,
useColonyAndPlatinum,
split,
rotateWhoStartsFirst,
startingDeckPerPlayer,
shouldParallel,
showVerboseScore,
showCompactScore,
showDistribution,
createHtmlReport,
createRankingReport,
numberOfGames,
logGameCount,
debugLogs,
createGameLog);
}
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);
}
public double ComparePlayers(
PlayerAction player1,
PlayerAction player2,
GameConfig gameConfig,
bool rotateWhoStartsFirst = true,
bool shouldParallel = true,
bool showVerboseScore = true,
bool showCompactScore = false,
bool showDistribution = false,
bool createHtmlReport = true,
bool createRankingReport = false,
int numberOfGames = 1000,
int logGameCount = 100,
bool debugLogs = false,
CreateGameLog createGameLog = null)
{
return ComparePlayers(new PlayerAction[] { player1, player2 },
gameConfig,
rotateWhoStartsFirst,
shouldParallel,
showVerboseScore,
showCompactScore,
showDistribution,
createHtmlReport,
createRankingReport,
numberOfGames,
logGameCount,
debugLogs,
createGameLog);
}
