public void Test_LeducHe()
{
GameDefinition gd = XmlSerializerExt.Deserialize <GameDefinition>(
Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/leduc-he.gamedef.xml"));
ChanceTree ct = CreateChanceTreeByGameDef.Create(gd);
using (TextWriter w = new StreamWriter(File.Open(Path.Combine(_outDir, "leduc-ct.gv"), FileMode.Create)))
{
VisChanceTree vis = new VisChanceTree {
Output = w, CardNames = gd.DeckDescr.CardNames
};
vis.Show(ct);
}
}
public void Test_Convert()
{
GameDefinition gd = XmlSerializerExt.Deserialize <GameDefinition>(
Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/leduc-he.gamedef.xml"));
string testDir = UTHelper.GetTestResourceDir(Assembly.GetExecutingAssembly());
ChanceTree ct1 = CreateChanceTreeByGameDef.Create(gd);
// DumpChanceTree.ToTxt(ct1, Console.Out);
MemoryStream ms = new MemoryStream();
using (TextWriter tw = new StreamWriter(ms))
{
DumpChanceTree.ToTxt(ct1, tw);
}
byte[] buf = ms.ToArray();
ms = new MemoryStream(buf);
ChanceTree ct2;
using (TextReader tr = new StreamReader(ms))
{
ct2 = DumpChanceTree.FromTxt(tr);
}
Assert.AreEqual(ct1.Version, ct2.Version);
Assert.AreEqual(ct1.NodesCount, ct2.NodesCount);
int roundsCount = ct1.CalculateRoundsCount();
double[] potShare1 = new double[ct1.PlayersCount];
double[] potShare2 = new double[ct1.PlayersCount];
for (Int64 n = 0; n < ct2.NodesCount; ++n)
{
Assert.AreEqual(ct1.GetDepth(n), ct2.GetDepth(n));
Assert.AreEqual(ct1.Nodes[n].Position, ct2.Nodes[n].Position);
Assert.AreEqual(ct1.Nodes[n].Card, ct2.Nodes[n].Card);
Assert.AreEqual(ct1.Nodes[n].Probab, ct2.Nodes[n].Probab);
if (ct1.GetDepth(n) == ct1.PlayersCount * roundsCount)
{
UInt16 [] activePlayerMasks = ActivePlayers.Get(ct1.PlayersCount, 2, ct1.PlayersCount);
foreach (UInt16 ap in activePlayerMasks)
{
ct1.Nodes[n].GetPotShare(ap, potShare1);
ct2.Nodes[n].GetPotShare(ap, potShare2);
Assert.AreEqual(potShare1, potShare2);
}
}
}
}
public void Test_Leduc()
{
GameDefinition gd = XmlSerializerExt.Deserialize <GameDefinition>(
Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/leduc-he.gamedef.xml"));
string[] strategyFilesRel = new string[] { "eq-LeducHe-0-s.xml", "eq-LeducHe-1-s.xml" };
string[] StrategyFilesAbs = new string[gd.MinPlayers].Fill(i => Path.Combine(_testResDir, strategyFilesRel[i]));
StrategyTree[] strategiesOrig = new StrategyTree[gd.MinPlayers].Fill(i =>
XmlToStrategyTree.Convert(StrategyFilesAbs[i], gd.DeckDescr));
ChanceTree ct = CreateChanceTreeByGameDef.Create(gd);
ActionTree at = CreateActionTreeByGameDef.Create(gd);
GameValue gv1 = new GameValue {
ActionTree = at, ChanceTree = ct, Strategies = strategiesOrig
};
gv1.Solve();
for (int p = 0; p < gd.MinPlayers; ++p)
{
StrategyTree[] strategiesMerged = new StrategyTree[gd.MinPlayers].Fill(i =>
XmlToStrategyTree.Convert(StrategyFilesAbs[i], gd.DeckDescr));
// Merge strategy to the stategy at postion p.
for (int pSrc = 0; pSrc < gd.MinPlayers; ++pSrc)
{
if (p == pSrc)
{
continue;
}
MergeStrategies.Merge(strategiesMerged[p], strategiesMerged[pSrc], pSrc);
}
// Copy strategy at position p to the other positions
for (int pCopy = 0; pCopy < gd.MinPlayers; ++pCopy)
{
strategiesMerged[pCopy] = strategiesMerged[p];
}
GameValue gv2 = new GameValue {
ActionTree = at, ChanceTree = ct, Strategies = strategiesMerged
};
gv2.Solve();
Assert.AreEqual(gv1.Values, gv2.Values);
}
}
public OcfrParams(GameValue_Test test, string name, string gameDefFile, IChanceAbstraction[] abstractions, string[] ocfrFiles, double[] expectedResult, double epsilon)
{
Epsilon = epsilon;
ExpectedResult = expectedResult;
GameDef = XmlSerializerExt.Deserialize <GameDefinition>(
Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/${0}",
gameDefFile));
Name = name;
OcfrFiles = new string[GameDef.MinPlayers].Fill(i => Path.Combine(test._testResDir, ocfrFiles[i]));
if (abstractions == null)
{
ChanceTree = CreateChanceTreeByGameDef.Create(GameDef);
}
else
{
ChanceTree = CreateChanceTreeByAbstraction.CreateS(GameDef, abstractions);
}
//VisChanceTree.Show(ChanceTree, Path.Combine(test._outDir, String.Format("{0}-c.gv", GameDef.Name)));
ActionTree = CreateActionTreeByGameDef.Create(GameDef);
StrategyTrees = new StrategyTree[GameDef.MinPlayers];
for (int p = 0; p < GameDef.MinPlayers; ++p)
{
ChanceTree pct = ExtractPlayerChanceTree.ExtractS(ChanceTree, p);
StrategyTrees[p] = CreateStrategyTreeByChanceAndActionTrees.CreateS(pct, ActionTree);
OpenCfrStrategyConverter conv = new OpenCfrStrategyConverter
{
GameDef = GameDef,
HeroPosition = p,
SourceFile = OcfrFiles[p],
Strategy = StrategyTrees[p],
ChanceAbstraction = abstractions == null ? null : abstractions[p]
};
conv.Convert();
//VisStrategyTree.Show(StrategyTrees[p], Path.Combine(test._outDir, String.Format("{0}-str-{1}.gv", GameDef.Name, p)));
}
}
public void Test_Leduc()
{
GameDefinition gd = XmlSerializerExt.Deserialize <GameDefinition>(
Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/leduc-he.gamedef.xml"));
ActionTree at = CreateActionTreeByGameDef.Create(gd);
ChanceTree ct = CreateChanceTreeByGameDef.Create(gd);
ChanceTree pct = ExtractPlayerChanceTree.ExtractS(ct, 0);
TestWalker tw = new TestWalker {
ActionTree = at, PlayerChanceTree = pct
};
tw.Walk();
Console.WriteLine("Begin: a:{0} c:{1} total:{2}", tw.BeginCount[0], tw.BeginCount[1], tw.BeginCount[0] + tw.BeginCount[1]);
Assert.AreEqual(674, tw.BeginCount[0]);
Assert.AreEqual(48, tw.BeginCount[1]);
Assert.AreEqual(_leduc, tw.Text);
}
public void Test_Kuhn()
{
GameDefinition gd = XmlSerializerExt.Deserialize <GameDefinition>(
Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/kuhn.gamedef.xml"));
ChanceTree ct = CreateChanceTreeByGameDef.Create(gd);
ActionTree at = CreateActionTreeByGameDef.Create(gd);
StrategyTree [] playerTrees = new StrategyTree[2];
for (int p = 0; p < 2; ++p)
{
ChanceTree pct = ExtractPlayerChanceTree.ExtractS(ct, p);
StrategyTree st = CreateStrategyTreeByChanceAndActionTrees.CreateS(pct, at);
playerTrees[p] = st;
VisStrategyTree.Show(st, Path.Combine(_outDir, string.Format("pt-{0}.gv", p)));
}
}
public void Test_Eq()
{
GameDefinition gd = XmlSerializerExt.Deserialize <GameDefinition>("kuhn8.gamedef.xml");
ChanceTree ct = CreateChanceTreeByGameDef.Create(gd);
VisChanceTree.Show(ct, "kuhn8-ct.gv");
ActionTree at = CreateActionTreeByGameDef.Create(gd);
VisActionTree.Show(at, "kuhn8-at.gv");
double[] values;
StrategyTree [] strategies = EqLp.Solve(at, ct, out values);
Console.WriteLine("Kuhn8 eq values: {0}, {1}", values[0], values[1]);
VisStrategyTree.Show(strategies[0], "kuhn8-eq-0.gv");
VisStrategyTree.Show(strategies[1], "kuhn8-eq-1.gv");
// Make strategy for T same as for Q
//strategies[0].Nodes[strategies[0].FindNode("0d0 0p0", null)].Probab = 0.5;
//strategies[0].Nodes[strategies[0].FindNode("0d0 0p0 1p1 0p1", null)].Probab = 0.5;
//strategies[0].Nodes[strategies[0].FindNode("0d0 0p1", null)].Probab = 0.5;
// Make strategy for Q same as for T
strategies[0].Nodes[strategies[0].FindNode("0d2 0p0", null)].Probab = 0;
strategies[0].Nodes[strategies[0].FindNode("0d2 0p0 1p1 0p1", null)].Probab = 0;
strategies[0].Nodes[strategies[0].FindNode("0d2 0p1", null)].Probab = 1;
VisStrategyTree.Show(strategies[0], "kuhn8-eq-0-adj.gv");
Br br = new Br {
ActionTree = at, ChanceTree = ct, HeroPosition = 1
};
br.Strategies = new StrategyTree[] { strategies[0], null };
br.Solve();
StrategyTree br0 = br.Strategies[1];
Console.WriteLine("Br against pos 0: {0}", br.Value);
VisStrategyTree.Show(strategies[1], "kuhn8-eq-br-0.gv");
}
public GameDefParams(GameValue_Test test, string gameDefFile, string[] strategyFiles, double[] expectedResult, double epsilon)
{
Epsilon = epsilon;
ExpectedResult = expectedResult;
GameDef = XmlSerializerExt.Deserialize <GameDefinition>(
Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/${0}",
gameDefFile));
Name = GameDef.Name;
StrategyFiles = new string[GameDef.MinPlayers].Fill(i => Path.Combine(test._testResDir, strategyFiles[i]));
StrategyTrees = new StrategyTree[GameDef.MinPlayers].Fill(i =>
XmlToStrategyTree.Convert(StrategyFiles[i], GameDef.DeckDescr));
ChanceTree = CreateChanceTreeByGameDef.Create(GameDef);
ActionTree = CreateActionTreeByGameDef.Create(GameDef);
}
public TestParams(Breb_Test test, string gameDefFile,
IChanceAbstraction chanceAbstr, double epsilon)
{
Epsilon = epsilon;
GameDef = XmlSerializerExt.Deserialize <GameDefinition>(Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/${0}", gameDefFile));
Name = chanceAbstr == null ? GameDef.Name : chanceAbstr.Name;
ChanceAbstraction = chanceAbstr;
ActionTree = CreateActionTreeByGameDef.Create(GameDef);
Debug.Assert(GameDef.MinPlayers == 2);
if (chanceAbstr == null)
{
ChanceTree = CreateChanceTreeByGameDef.Create(GameDef);
}
else
{
ChanceTree = CreateChanceTreeByAbstraction.CreateS(GameDef,
new IChanceAbstraction[]
{ chanceAbstr, chanceAbstr });
}
}
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));
}
}
}
public void Test_Verify()
{
string [] strFiles = new string[] { "eq-KunhPoker-0-s.xml", "eq-KunhPoker-1-s.xml" };
GameDefinition gd = XmlSerializerExt.Deserialize <GameDefinition>(
Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/kuhn.gamedef.xml"));
StrategyTree[] st = new StrategyTree[gd.MinPlayers];
for (int i = 0; i < gd.MinPlayers; ++i)
{
string strPath = Path.Combine(_testResDir, strFiles[i]);
st[i] = XmlToStrategyTree.Convert(strPath, gd.DeckDescr);
}
ActionTree at = CreateActionTreeByGameDef.Create(gd);
ChanceTree ct = CreateChanceTreeByGameDef.Create(gd);
string error;
Assert.IsTrue(VerifyEq.Verify(at, ct, st, 0.0000001, out error), error);
// Now modify the strategy (with a J: not always fold to a r)
st[1].Nodes[10].Probab = 0.5;
st[1].Nodes[11].Probab = 0.5;
Assert.IsFalse(VerifyEq.Verify(at, ct, st, 0.0000001, out error));
}
private static bool ProcessStrategyTree()
{
StrategyTree tree;
if (_cmdLine.Input != "")
{
if (_inputFormat == ".dat")
{
tree = UFTree.Read <StrategyTree>(_cmdLine.Input);
}
else if (_inputFormat == ".txt")
{
tree = DumpStrategyTree.FromTxt(_cmdLine.Input);
}
else
{
Console.Error.WriteLine("Unsupported input format '{0}' for tree kind '{1}'", _inputFormat, _cmdLine.TreeKind);
return(false);
}
}
else
{
ActionTree at = CreateActionTreeByGameDef.Create(_gd);
ChanceTree ct = CreateChanceTreeByGameDef.Create(_gd);
ChanceTree pct = ExtractPlayerChanceTree.ExtractS(ct, _cmdLine.Position);
tree = CreateStrategyTreeByChanceAndActionTrees.CreateS(pct, at);
}
if (_outputFormat == ".gv")
{
using (TextWriter w = new StreamWriter(File.Open(_cmdLine.Output, FileMode.Create)))
{
VisStrategyTree vis = new VisStrategyTree {
Output = w
};
if (_gd != null)
{
vis.CardNames = _gd.DeckDescr.CardNames;
}
if (_cmdLine.ClearExpr)
{
vis.ShowExpr.Clear();
}
vis.ShowExprFromString(_cmdLine.ShowExpr);
vis.PruneIfExt = (t, n, s, d) => s[d].Round > _cmdLine.MaxRound;
vis.MatchPath = _cmdLine.MatchPath;
vis.Show(tree, _cmdLine.Root);
}
}
else if (_outputFormat == ".xml")
{
using (TextWriter w = new StreamWriter(File.Open(_cmdLine.Output, FileMode.Create)))
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.ASCII;
settings.Indent = true;
using (XmlWriter xmlWriter = XmlWriter.Create(w, settings))
{
StrategyTreeToXml xmlizer = new StrategyTreeToXml {
Output = xmlWriter
};
if (_cmdLine.ClearExpr)
{
xmlizer.ShowExpr.Clear();
}
xmlizer.ShowExprFromString(_cmdLine.ShowExpr);
xmlizer.Convert(tree);
}
}
}
else if (_outputFormat == ".dat")
{
tree.Write(_cmdLine.Output);
}
else if (_outputFormat == ".txt")
{
DumpStrategyTree.ToTxt(tree, _cmdLine.Output);
}
else
{
Console.Error.WriteLine("Unsupported ouput format '{0}' for tree kind '{1}'", _outputFormat, _cmdLine.TreeKind);
return(false);
}
return(true);
}
private static bool ProcessChanceTree()
{
ChanceTree tree;
if (_cmdLine.Input != "")
{
if (_inputFormat == ".dat")
{
tree = UFTree.Read <ChanceTree>(_cmdLine.Input);
}
else if (_inputFormat == ".txt")
{
tree = DumpChanceTree.FromTxt(_cmdLine.Input);
}
else
{
Console.Error.WriteLine("Unsupported input format '{0}' for tree kind '{1}'", _inputFormat, _cmdLine.TreeKind);
return(false);
}
}
else
{
tree = CreateChanceTreeByGameDef.Create(_gd);
if (_cmdLine.TreeKind == "chance-player")
{
ChanceTree pt = ExtractPlayerChanceTree.ExtractS(tree, _cmdLine.Position);
tree = pt;
}
}
if (_outputFormat == ".gv")
{
using (TextWriter w = new StreamWriter(File.Open(_cmdLine.Output, FileMode.Create)))
{
VisChanceTree vis = new VisChanceTree {
Output = w
};
if (_gd != null)
{
vis.CardNames = _gd.DeckDescr.CardNames;
}
if (_cmdLine.ClearExpr)
{
vis.ShowExpr.Clear();
}
vis.ShowExprFromString(_cmdLine.ShowExpr);
vis.PruneIfExt = (t, n, s, d) => s[d].Round > _cmdLine.MaxRound;
vis.MatchPath = _cmdLine.MatchPath;
vis.Show(tree);
}
}
else if (_outputFormat == ".dat")
{
tree.Write(_cmdLine.Output);
}
else if (_outputFormat == ".txt")
{
DumpChanceTree.ToTxt(tree, _cmdLine.Output);
}
else
{
Console.Error.WriteLine("Unsupported output format '{0}' for tree kind '{1}'", _outputFormat, _cmdLine.TreeKind);
return(false);
}
return(true);
}
