static int Main(string[] args)
{
if (!Parser.ParseArgumentsWithUsage(args, _cmdLine))
{
return(1);
}
if (_cmdLine.DebuggerLaunch)
{
Debugger.Launch();
}
ChanceTree ct = ChanceTree.Read <ChanceTree>(_cmdLine.ChanceTree);
if (_cmdLine.Verify)
{
Console.Write("Verifying tree ...");
VerifyChanceTree.VerifyS(ct);
Console.WriteLine(" OK");
}
AnalyzeChanceTree.AnalyzeS(ct);
return(0);
}
/// <summary>
/// This functions simulate a typical use case: create trees in many runs of MC sampling, write them, read again
/// and merge into the master tree. The master tree is than verified.
/// </summary>
private void GenerateAndVerifyCT(string name, GameDefinition gd, IChanceAbstraction[] chanceAbstractions, bool areAbstractionsEqual, int samplesCount, int runsCount, double avRelProbabEps, double avPotShareEps, double eqValEps, bool visualize)
{
CtMcGen.Tree masterTree = new CtMcGen.Tree();
int rngSeed = (int)DateTime.Now.Ticks;
for (int run = 0; run < runsCount; ++run)
{
CtMcGen.Tree runTree = CtMcGen.Generate(gd, chanceAbstractions, areAbstractionsEqual, samplesCount, rngSeed, null);
string fileName = Path.Combine(_outDir, String.Format("{0}-{1}-ct.dat", gd.Name, name));
runTree.Write(fileName);
masterTree.Read(fileName);
// Do not use the timer anymore because the tests are too fast.
rngSeed++;
}
ChanceTree actCt = masterTree.ConvertToChanceTree();
VisChanceTree.Show(actCt, Path.Combine(_outDir, String.Format("{0}-{1}-ct.gv", gd.Name, name)));
VerifyChanceTree.VerifyS(actCt);
ChanceTree expCt = CreateChanceTreeByAbstraction.CreateS(gd, chanceAbstractions);
Assert.AreEqual(expCt.PlayersCount, actCt.PlayersCount);
CompareChanceTrees cmp = new CompareChanceTrees();
cmp.IsVerbose = visualize;
cmp.Output = Console.Out;
cmp.Compare(expCt, actCt);
VisChanceTree.Show(expCt, Path.Combine(_outDir, String.Format("{0}-{1}-ct-exp.gv", gd.Name, name)));
Assert.Less(cmp.AverageRelProbabDiff, avRelProbabEps);
for (int p = 0; p < chanceAbstractions.Length; ++p)
{
Assert.Less(cmp.AveragePotShareDiff[p], avRelProbabEps);
}
ActionTree at = CreateActionTreeByGameDef.Create(gd);
double [] actEqValues, expEqValues;
EqLp.Solve(at, actCt, out actEqValues);
EqLp.Solve(at, expCt, out expEqValues);
for (int p = 0; p < chanceAbstractions.Length; ++p)
{
if (visualize)
{
Console.WriteLine("Eq pos: {0} exp: {1} act: {2}", p, expEqValues[p], actEqValues[p]);
}
Assert.AreEqual(expEqValues[p], actEqValues[p], eqValEps);
}
if (visualize)
{
Console.WriteLine();
}
}
private void DoVerifyChanceTree(ChanceTree ct)
{
Assert.AreEqual(ct.PlayersCount, _gd.MinPlayers);
try
{
VerifyChanceTree.VerifyS(ct);
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
WalkUFTreePP <ChanceTree, Context> wt = new WalkUFTreePP <ChanceTree, Context>();
wt.OnNodeBegin = OnNodeBegin;
wt.OnNodeEnd = OnNodeEnd;
wt.Walk(ct);
}
private ChanceTree CreateCt(HePocketKind[] sbCards, HePocketKind[] bbCards)
{
int nodeCount = 1 + sbCards.Length + sbCards.Length * bbCards.Length;
ChanceTree ct = new ChanceTree(nodeCount);
ct.PlayersCount = 2;
ct.Nodes[0].Probab = 1;
ct.SetDepth(0, 0);
int totalCombSB = 0;
foreach (HePocketKind p in sbCards)
{
totalCombSB += HePocket.KindToRange(p).Length;
}
for (int c0 = 0; c0 < sbCards.Length; ++c0)
{
int sbNode = 1 + c0 * (bbCards.Length + 1);
HePocketKind sbPocket = sbCards[c0];
ct.SetDepth(sbNode, 1);
ct.Nodes[sbNode].Position = 0;
ct.Nodes[sbNode].Probab = (double)HePocket.KindToRange(sbPocket).Length / totalCombSB;
ct.Nodes[sbNode].Card = c0;
double[] oppDealProbabCond = PocketHelper.GetProbabDistr(bbCards, HePocket.KindToCardSet(sbPocket));
for (int c1 = 0; c1 < bbCards.Length; ++c1)
{
int bbNode = sbNode + 1 + c1;
ct.SetDepth(bbNode, 2);
ct.Nodes[bbNode].Position = 1;
ct.Nodes[bbNode].Probab = ct.Nodes[sbNode].Probab * oppDealProbabCond[c1];
ct.Nodes[bbNode].Card = c1;
PocketEquity.Result pe = PocketEquity.CalculateFast(sbPocket, bbCards[c1]);
var potShare = new double[] { pe.Equity, 1 - pe.Equity };
ct.Nodes[bbNode].SetPotShare(3, potShare);
}
}
VerifyChanceTree.VerifyS(ct, 1e-5);
return(ct);
}
public void Test_Kuhn()
{
GameDefinition gd = XmlSerializerExt.Deserialize <GameDefinition>(
Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/kuhn.gamedef.xml"));
IChanceAbstraction[] abstractions = new IChanceAbstraction [] { new KuhnChanceAbstraction(), new KuhnChanceAbstraction() };
ChanceTree ct = CreateChanceTreeByGameDef.Create(gd);
ChanceTree act = CreateChanceTreeByAbstraction.CreateS(gd, abstractions);
VerifyChanceTree.VerifyS(act);
VisChanceTree.Show(act, Path.Combine(_outDir, gd.Name + "-abct.gv"));
UInt16[] activePlayersOne = ActivePlayers.Get(gd.MinPlayers, 1, 1);
UInt16[] activePlayersAll = ActivePlayers.Get(gd.MinPlayers, 1, gd.MinPlayers);
int maxDepth = gd.RoundsCount * gd.MinPlayers;
Assert.AreEqual(act.PlayersCount, gd.MinPlayers);
Assert.AreEqual(ct.NodesCount, act.NodesCount);
double[] expPotShares = new double[gd.MinPlayers];
double[] actPotShares = new double[gd.MinPlayers];
for (int i = 0; i < ct.NodesCount; ++i)
{
Assert.AreEqual(ct.Nodes[i].Position, act.Nodes[i].Position);
Assert.AreEqual(ct.Nodes[i].Card, act.Nodes[i].Card); // Kuhn abstraction has the same card
Assert.AreEqual(ct.Nodes[i].Probab, act.Nodes[i].Probab);
if (i == 0)
{
continue;
}
UInt16[] activePlayers = ct.GetDepth(i) == maxDepth ? activePlayersAll : activePlayersOne;
foreach (UInt16 ap in activePlayers)
{
ct.Nodes[i].GetPotShare(ap, expPotShares);
act.Nodes[i].GetPotShare(ap, actPotShares);
Assert.AreEqual(expPotShares, actPotShares, String.Format("Node: {0}, ap: {1}", i, ap));
}
}
}
private void CreateAndVerifyPlayerTrees(GameDefinition gd, ChanceTree ct, double [] expectedProbabs)
{
for (int pos = 0; pos < gd.MinPlayers; ++pos)
{
ChanceTree pct = ExtractPlayerChanceTree.ExtractS(ct, pos);
string fileName = string.Format("{0}-{1}.gv", gd.Name, pos);
using (TextWriter w = new StreamWriter(File.Open(Path.Combine(_outDir, fileName), FileMode.Create)))
{
VisChanceTree vis = new VisChanceTree {
Output = w, CardNames = gd.DeckDescr.CardNames
};
vis.Show(pct);
}
Assert.AreEqual(1, pct.PlayersCount);
Assert.AreEqual(expectedProbabs.Length, pct.NodesCount);
VerifyChanceTree.VerifyS(pct);
for (int i = 0; i < expectedProbabs.Length; ++i)
{
Assert.AreEqual(expectedProbabs[i], pct.Nodes[i].Probab, 0.00000000001, string.Format("Node {0}", i));
}
}
}
public static ChanceTree CreateCt(HePocketKind [] pockets, double [] oppCardProbab)
{
int n = pockets.Count();
double[] dealProbab = PocketHelper.GetProbabDistr(pockets);
int nodeCount = 1 + n + n * n;
ChanceTree ct = new ChanceTree(nodeCount);
ct.PlayersCount = 2;
ct.Nodes[0].Probab = 1;
ct.SetDepth(0, 0);
for (int c0 = 0; c0 < n; ++c0)
{
int heroNode = 1 + c0 * (n + 1);
ct.SetDepth(heroNode, 1);
ct.Nodes[heroNode].Position = 0;
ct.Nodes[heroNode].Probab = dealProbab[c0];
ct.Nodes[heroNode].Card = c0;
double[] corrOppProbab = CorrectOpponentProbab(pockets, c0, dealProbab, oppCardProbab);
for (int c1 = 0; c1 < n; ++c1)
{
int oppNode = heroNode + 1 + c1;
ct.SetDepth(oppNode, 2);
ct.Nodes[oppNode].Position = 1;
ct.Nodes[oppNode].Probab = ct.Nodes[heroNode].Probab * corrOppProbab[c1];
ct.Nodes[oppNode].Card = c1;
PocketEquity.Result pe = PocketEquity.CalculateFast(pockets[c0], pockets[c1]);
var potShare = new double[] { pe.Equity, 1 - pe.Equity };
ct.Nodes[oppNode].SetPotShare(3, potShare);
}
}
VerifyChanceTree.VerifyS(ct, 1e-5);
return(ct);
}
