public StrategyTree Create(ChanceTree playerChanceTree, ActionTree actionTree) { Creator c = new Creator { ActionTree = actionTree, PlayerChanceTree = playerChanceTree }; // Start from 1 because the root is skipped. c.NodeCount = 1; c.Walk(); c.StrategyTree = new StrategyTree(c.NodeCount); c.NodeCount = 1; c.Walk(); // Set root c.StrategyTree.SetDepth(0, 0); c.StrategyTree.Nodes[0].IsDealerAction = false; c.StrategyTree.Nodes[0].Position = actionTree.Nodes[0].Position; c.StrategyTree.Nodes[0].Amount = 0; c.StrategyTree.Nodes[0].Probab = 0; c.StrategyTree.Version.Description = String.Format("Strategy tree from {0}, {1}", actionTree.Version.Description, playerChanceTree.Version.Description); return(c.StrategyTree); }
protected override bool OnNodeBeginFunc(UFToUniAdapter aTree, int aNode, List <VisActionTreeContext> stack, int depth) { VisActionTreeContext context = stack[depth]; ActionTree tree = (ActionTree)(aTree.UfTree); context.Tree = tree; if (depth == 0) { context.State = new StrategicState(tree.PlayersCount); } else { context.State = stack[depth - 1].State.GetNextState(tree.Nodes[aNode]); } context.Id = aNode.ToString(); context.IsDealerAction = false; context.Position = tree.Nodes[aNode].Position; context.Round = tree.Nodes[aNode].Round; context.ActivePlayers = tree.Nodes[aNode].ActivePlayers; context.ActionLabel = depth == 0 ? "" : tree.Nodes[aNode].ToStrategicString(null); return(base.OnNodeBeginFunc(aTree, aNode, stack, depth)); }
public void PlayEliminate(List <MonsterAnimInfo> monsterAnimss, ActionTree actionTree) { for (int j = 0; j < monsterAnimss.Count; j++) { OrderAction order = new OrderAction(); MonsterAnimInfo monsterAnimInfo = monsterAnimss[j]; FightMonsterItem item = GetItemByRunId(monsterAnimInfo.monsterInfo.runId); switch (monsterAnimInfo.animationType) { case CellAnimType.clear: order.AddNode(new ShowEffectActor(item.transform, "effect_cell_bomb", fightModule.transform)); order.AddNode(new PlaySoundActor("remove")); order.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0, 0, 0), 0.1f)); order.AddNode(new DestroyActor(item.gameObject)); break; case CellAnimType.wreck: order.AddNode(new ShowEffectActor(item.transform, "effect_cell_bomb", fightModule.transform)); order.AddNode(new PlaySoundActor("remove")); order.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0, 0, 0), 0.1f)); //if (monsterAnimInfo.monsterInfo.IsNull()) //{ // order.AddNode(new DestroyActor(item.gameObject)); //}else //{ order.AddNode(new ChangeMonsterActor(item, monsterAnimInfo.monsterInfo)); //} break; } actionTree.AddNode(order); } }
static void Main(string[] args) { Tree <Student> student = new Tree <Student>(Tree <Student> .CompareFuncByMark); student.onAdd += ShowMessage; student.AddNodeRecursion(new Student("Sasha", "Epam", new DateTime(2019, 5, 5), -10)); student.AddNodeRecursion(new Student("Sasha", "Epam", new DateTime(2019, 5, 5), 1)); student.AddNodeRecursion(new Student("Sasha", "Epam", new DateTime(2019, 5, 5), -5)); student.AddNodeRecursion(new Student("Sasha", "Epam", new DateTime(2019, 5, 5), 6)); student.AddNodeRecursion(new Student("Sasha", "Epam", new DateTime(2019, 5, 5), -11)); student.AddNodeRecursion(new Student("Sasha", "Epam", new DateTime(2019, 5, 5), 20)); student.AddNodeRecursion(new Student("Sasha", "Epam", new DateTime(2019, 5, 5), -8)); student.AddNodeRecursion(new Student("Sasha", "Epam", new DateTime(2019, 5, 5), 2)); student.AddNodeRecursion(new Student("Sasha", "Epam", new DateTime(2019, 5, 5), -12)); student.AddNodeRecursion(new Student("Sasha", "Epam", new DateTime(2019, 5, 5), 0)); student.AddNodeRecursion(new Student("Sasha", "Epam", new DateTime(2019, 5, 5), -45)); student.AddNodeRecursion(new Student("Sasha", "Epam", new DateTime(2019, 5, 5), 100)); Console.WriteLine("Tree:"); ActionTree.TreeAHeadDirectRecursion(student.root); Console.WriteLine("Count of Childrens:"); student.onCount += ShowMessage; student.CountChildrens(student.root); Console.ReadKey(); }
public void Flow(ActionTree actionTree) { FloorModel.Instance.Flow(); List <FloorAnimInfo> anims = FloorModel.Instance.anims[0]; for (int i = 0; i < anims.Count; i++) { FloorAnimInfo animInfo = anims[i]; FightFloorItem item = GetItemByRunId(animInfo.floorInfo.runId); if (item != null) { ParallelAction paralle = new ParallelAction(); Vector2 toPos = PosMgr.GetFightCellPos(animInfo.floorInfo.posX, animInfo.floorInfo.posY); paralle.AddNode(new MoveActor((RectTransform)item.transform, new Vector3(toPos.x, toPos.y, 0), 0, 0.3f)); OrderAction orderAction = new OrderAction(); orderAction.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0.5f, 0.5f, 1), 0.1f)); orderAction.AddNode(new WaitActor(100)); orderAction.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(1, 1, 1), 0.1f)); paralle.AddNode(orderAction); actionTree.AddNode(paralle); } } }
public void InitActionTreeCallback() { ActionTree.SuspendLayout(); int selectedIndex = -1; if (ActionTree.SelectedNode != null) selectedIndex = ActionTree.Nodes.IndexOf(ActionTree.SelectedNode); ActionTree.Nodes.Clear(); foreach (IPBComposite composite in PB.CurrentProfile.Branch.Children) { TreeNode node = new TreeNode(composite.Title); node.ForeColor = composite.Color; node.Tag = composite; if (composite is GroupComposite) { ActionTreeAddChildren((GroupComposite)composite, node); } ActionTree.Nodes.Add(node); } //ActionTree.ExpandAll(); if (selectedIndex != -1) { if (selectedIndex < ActionTree.Nodes.Count) ActionTree.SelectedNode = ActionTree.Nodes[selectedIndex]; else ActionTree.SelectedNode = ActionTree.Nodes[ActionTree.Nodes.Count - 1]; } ActionTree.ResumeLayout(); }
public void PlayEliminate(List <CoverAnimInfo> coverAnimss, ActionTree actionTree) { for (int j = 0; j < coverAnimss.Count; j++) { OrderAction order = new OrderAction(); CoverAnimInfo coverAnimInfo = coverAnimss[j]; FightCoverItem item = GetItemByRunId(coverAnimInfo.coverInfo.runId); switch (coverAnimInfo.animationType) { case CellAnimType.clear: order.AddNode(new ShowEffectActor(item.transform, "effect_cell_bomb", fightModule.transform)); order.AddNode(new PlaySoundActor("remove")); order.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0, 0, 0), 0.1f)); order.AddNode(new DestroyActor(item.gameObject)); break; case CellAnimType.wreck: order.AddNode(new ShowEffectActor(item.transform, "effect_cell_bomb", fightModule.transform)); order.AddNode(new PlaySoundActor("remove")); order.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0, 0, 0), 0.1f)); order.AddNode(new ChangeCoverActor(this, item, coverAnimInfo.coverInfo)); break; } actionTree.AddNode(order); } }
public void Solve(ActionTree at, HePocketKind[] sbCards, HePocketKind[] bbCards) { Ct = CreateCt(sbCards, bbCards); var gv = new double[2]; Strategies = EqLp.Solve(at, Ct, out gv); GameValues = gv; }
protected override void OnTreeBeginFunc(UFToUniAdapter aTree, int aRoot) { ActionTree tree = (ActionTree)(aTree.UfTree); GraphAttributes.label = tree.Version.Description; GraphAttributes.fontsize = 20; base.OnTreeBeginFunc(aTree, aRoot); }
public void Test_LeducHe() { _gd = XmlSerializerExt.Deserialize <GameDefinition>( Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/leduc-he.gamedef.xml")); ActionTree tree = CreateActionTreeByGameDef.Create(_gd); VerifyActionTree(tree, _expLeducHe); }
private static void ProcessGameContext(GameContext context) { int nodeId = context.Global.NodeId++; GameDefinition gd = context.Global.GameDef; ActionTree tree = context.Global.Tree; // Store it before we possible change the state to skip dealer actions. int lastActor = context.GameState.LastActor; int round = context.GameState.Round; while (!context.GameState.IsGameOver && context.GameState.IsDealerActing) { List <Ak> kinds = context.GameState.GetAllowedActions(gd); foreach (Ak kind in kinds) { PokerAction action = new PokerAction { Kind = kind, Position = context.GameState.CurrentActor }; context.GameState.UpdateByAction(action, gd); } } if (tree != null) { tree.SetDepth(nodeId, (byte)context.Depth); tree.Nodes[nodeId].Position = lastActor; tree.Nodes[nodeId].Amount = context.Amount; tree.Nodes[nodeId].ActivePlayers = context.GameState.GetActivePlayers(); tree.Nodes[nodeId].Round = round; } if (context.GameState.IsGameOver) { return; } // Deal next cards. List <Ak> actions = context.GameState.GetAllowedActions(gd); foreach (Ak actionKind in actions) { GameContext childContext = new GameContext(context); childContext.Depth++; int position = context.GameState.CurrentActor; PokerAction a = new PokerAction(actionKind, position, 0, ""); if (a.Kind == Ak.r) { a.Amount = gd.BetStructure[context.GameState.Round]; } childContext.GameState.UpdateByAction(a, gd); childContext.Amount = childContext.GameState.Players[position].InPot - context.GameState.Players[position].InPot; ProcessGameContext(childContext); context.ChildCount += childContext.ChildCount + 1; } }
public static StrategyTree CreateStrategyTree(GameDefinition gd, int pos) { ChanceTree ct = CreateChanceTreeByGameDef.Create(gd); ChanceTree pct = ExtractPlayerChanceTree.ExtractS(ct, 0); ActionTree at = CreateActionTreeByGameDef.Create(gd); StrategyTree st = CreateStrategyTreeByChanceAndActionTrees.CreateS(pct, at); return(st); }
public void InitActionTree() { if (!IsValid) return; if (ActionTree.InvokeRequired) ActionTree.BeginInvoke(new guiInvokeCB(InitActionTreeCallback)); else InitActionTreeCallback(); }
void Initialize() { DateTime startTime = DateTime.Now; _at = ActionTree.Read <ActionTree>(ActionTreeFile); if (IsVerbose) { Console.WriteLine("Action tree: {0}", _at.Version.ToString()); } _init = new InitData(this); _playersCount = _at.PlayersCount; _epsilonLog = new List <EpsilonLogEntry>(); _snapshotSwitcher = new SnapshotSwitcher(OutputPath, GetSnapshotHeaderFileName(), SnapshotsCount); _curSnapshotInfo = new SnapshotInfo(_snapshotSwitcher.CurrentSnapshotPath, _playersCount); IterationCounts = new int[_playersCount]; LastBrValues = new double[_playersCount]; _ptExt = new Node[_playersCount][]; _rng = new System.Random(RngSeed); _mcDealer = new McDealer(GameDef, _rng); _hands = new int[_playersCount][].Fill(i => new int[_mcDealer.HandSize]); _handSizes = GameDef.GetHandSizes(); _oppGv = new double[_at.NodesCount]; bool isNewSnapshot = !_snapshotSwitcher.IsSnapshotAvailable; if (isNewSnapshot) { CreateNewSnapshot(); } //LoadSnapshot(); CreatePlayerTrees(); for (int p = 0; p < _playersCount; ++p) { if (TraceDir != null) { Vis.Show(this, p, GetTraceFileName(p, "tree", "init-pt", "gv")); } } if (TraceDir != null) { VisChanceTree.Show(_init.PlayerCt, GetTraceFileName(0, "pct", "", "gv")); } PrintInitDone(); // Clean-up _init = null; double time = (DateTime.Now - startTime).TotalSeconds; if (IsVerbose) { Console.WriteLine("Initialization done in {0:0.0} s", time); } }
private void RefreshActionTreeCallback(IPBComposite pbComp, Type type) { ActionTree.SuspendLayout(); foreach (TreeNode node in ActionTree.Nodes) { UdateTreeNode(node, pbComp, type, true); } ActionTree.ResumeLayout(); }
public static void Show(ActionTree t, string fileName) { using (TextWriter w = new StreamWriter(File.Open(fileName, FileMode.Create))) { VisActionTree vis = new VisActionTree { Output = w }; vis.Show(t); } }
/// <summary> /// Refreshes all actions of specified type in ActionTree or all if type is null /// </summary> /// <param name="type"></param> public void RefreshActionTree(IPBComposite pbComp, Type type) { // Don't update ActionTree while PB is running to improve performance. if (PB.IsRunning || !IsValid) return; if (ActionTree.InvokeRequired) ActionTree.BeginInvoke(new refreshActionTreeDelegate(RefreshActionTreeCallback), pbComp, type); else RefreshActionTreeCallback(pbComp, type); }
/// <summary> /// Runs FictitiousPlay with the specified parameters. /// Some parameters are set by default (e.g. verbosity), the caller has a chance to overwrite them /// using Configure delegate. /// </summary> public StrategyTree[] Solve(ActionTree at, ChanceTree ct) { int playersCount = 2; DirectoryExt.Delete(BaseDir); Directory.CreateDirectory(BaseDir); string inputDir = Path.Combine(BaseDir, "input"); Directory.CreateDirectory(inputDir); string traceDir = Path.Combine(BaseDir, "trace"); string chanceTreeFile = Path.Combine(inputDir, "ct.dat"); string actionTreeFile = Path.Combine(inputDir, "at.dat"); ct.Write(chanceTreeFile); at.Write(actionTreeFile); if (VisualizeTrees) { VisActionTree.Show(at, actionTreeFile + ".gv"); VisChanceTree.Show(ct, chanceTreeFile + ".gv"); } Solver.ChanceTreeFile = chanceTreeFile; Solver.EqualCa = false; Solver.ActionTreeFile = actionTreeFile; Solver.OutputPath = BaseDir; Solver.SnapshotsCount = 2; Solver.Epsilon = Epsilon; Solver.ThreadsCount = 6; Solver.IsVerbose = true; Solver.IterationVerbosity = 10000; Solver.MaxIterationCount = 1000000000; if (Configure != null) { Configure(Solver); } Solver.Solve(); StrategyTree[] eqStrategies = new StrategyTree[playersCount]; for (int p = 0; p < playersCount; ++p) { string fileName = Solver.CurrentSnapshotInfo.StrategyFile[p]; eqStrategies[p] = StrategyTree.Read <StrategyTree>(fileName); if (VisualizeTrees) { VisStrategyTree.Show(eqStrategies[p], fileName + ".gv"); } } return(eqStrategies); }
private long FindActionTreeNodeIdx(StrategyTree tree, long sNodeIdx, long aNodeIdx, int hintChildIdx) { long actionTreeIdx = ActionTree.FindChildByAmount(aNodeIdx, tree.Nodes[sNodeIdx].Amount, _actionTreeIndex, hintChildIdx); if (actionTreeIdx == -1) { throw new ApplicationException(String.Format("Cannot find action tree node, strategy node {0}", sNodeIdx)); } return(actionTreeIdx); }
/// <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(); } }
public void PlayEliminate(List <FloorAnimInfo> floorAnimss, ActionTree actionTree) { for (int j = 0; j < floorAnimss.Count; j++) { OrderAction order = new OrderAction(); FloorAnimInfo floorAnimInfo = floorAnimss[j]; FightFloorItem item = GetItemByRunId(floorAnimInfo.floorInfo.runId); order.AddNode(new ScaleActor((RectTransform)item.transform, new Vector3(0, 0, 0), 0.1f)); order.AddNode(new DestroyActor(item.gameObject)); actionTree.AddNode(order); } }
public static ActionTree Create(GameDefinition gd) { // First pass - count nodes. GlobalContext gc = new GlobalContext { GameDef = gd }; GameContext root = new GameContext { GameState = new GameState(gd), Global = gc }; ProcessGameContext(root); // Create the tree, adding actions for blinds int nodeCount = root.ChildCount + 1 + gd.MinPlayers; ActionTree tree = new ActionTree(nodeCount); // Second pass - initialize nodes. gc.Tree = tree; // Start from the last blind node gc.NodeId = gd.MinPlayers; root.Depth = gd.MinPlayers; ProcessGameContext(root); // Now fill the root and blind nodes (overwriting the last one, because it is wrong). gc.NodeId = 0; root.Depth = 0; // Set data for root. tree.SetDepth(gc.NodeId, (byte)root.Depth++); tree.Nodes[gc.NodeId].Position = gd.MinPlayers; tree.Nodes[gc.NodeId].Amount = 0; tree.Nodes[gc.NodeId].ActivePlayers = root.GameState.GetActivePlayers(); tree.Nodes[gc.NodeId].Round = -1; gc.NodeId++; // Set data for blinds for (int p = 0; p < gd.MinPlayers; ++p) { tree.SetDepth(gc.NodeId, (byte)root.Depth++); tree.Nodes[gc.NodeId].Position = p; tree.Nodes[gc.NodeId].Amount = root.GameState.Players[p].InPot; tree.Nodes[gc.NodeId].ActivePlayers = root.GameState.GetActivePlayers(); tree.Nodes[gc.NodeId].Round = -1; gc.NodeId++; } tree.Version.Description = String.Format("Action tree (gamedef: {0})", gd.Name); return(tree); }
public TestParams(FictitiousPlayMc_Test test, string gameDefFile, IChanceAbstraction chanceAbstr, int [] cardCount, double epsilon) { Epsilon = epsilon; GameDef = XmlSerializerExt.Deserialize <GameDefinition>(Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/${0}", gameDefFile)); Name = chanceAbstr.Name; ChanceAbstraction = chanceAbstr; ActionTree = CreateActionTreeByGameDef.Create(GameDef); Debug.Assert(GameDef.MinPlayers == 2); ChanceTree = CreateChanceTreeByAbstraction.CreateS(GameDef, new IChanceAbstraction[] { chanceAbstr, chanceAbstr }); CardCount = cardCount; }
private unsafe void VerifyActionTree(ActionTree tree, VerificationData[] expected) { Assert.AreEqual(tree.PlayersCount, _gd.MinPlayers); Assert.AreEqual(expected.Length, tree.NodesCount); for (int i = 0; i < tree.NodesCount; ++i) { Assert.AreEqual(expected[i].Depth, tree.GetDepth(i), String.Format("Node id {0}", i)); Assert.AreEqual(expected[i].Position, tree.Nodes[i].Position, String.Format("Node id {0}", i)); Assert.AreEqual(expected[i].Amount, tree.Nodes[i].Amount, String.Format("Node id {0}", i)); Assert.AreEqual(expected[i].Round, tree.Nodes[i].Round, String.Format("Node id {0}", i)); Assert.AreEqual(expected[i].ActivePlayers, tree.Nodes[i].ActivePlayers, String.Format("Node id {0}", i)); } }
static int Main(string[] args) { if (!Parser.ParseArgumentsWithUsage(args, _cmdLine)) { return(1); } if (_cmdLine.DebuggerLaunch) { Debugger.Launch(); } GameDefinition gd = XmlSerializerExt.Deserialize <GameDefinition>(_cmdLine.GameDef.Get(Props.Global)); string chanceTreeFile = _cmdLine.ChanceTree.Get(Props.Global); ChanceTree ct; if (string.IsNullOrEmpty(chanceTreeFile)) { ct = CreateChanceTreeByGameDef.Create(gd); } else { ct = ChanceTree.Read <ChanceTree>(chanceTreeFile); } ActionTree at = CreateActionTreeByGameDef.Create(gd); double [] values; StrategyTree [] st = EqLp.Solve(at, ct, out values); if (st == null) { Console.WriteLine("Cannot find solution"); return(1); } string output = _cmdLine.Output.Get(Props.Global); string basePath = string.IsNullOrEmpty(output) ? gd.Name : output; string baseDir = Path.GetDirectoryName(basePath); string baseName = Path.GetFileNameWithoutExtension(basePath); for (int p = 0; p < st.Length; ++p) { string fileName = Path.Combine(baseDir, string.Format("{0}-{1}.dat", baseName, p)); Console.WriteLine("Eq value pos {0}: {1}, file: {2}", p, values[p], fileName); st[p].Write(fileName); } return(0); }
/// <summary> /// Solves a game for one position. If solution is found, returns it, otherwise returns null. /// </summary> public static StrategyTree Solve(ActionTree at, ChanceTree ct, int heroPos, out double value) { EqLp solver = new EqLp { ChanceTree = ct, ActionTree = at, HeroPosition = heroPos }; solver.Solve(); value = solver.Value; if (!solver.IsLpSolutionFound) { return(null); } return(solver.Strategy); }
/// <summary> /// Solves a game for all positions. If solution for all positions is found, returns it, otherwise returns null. /// </summary> public static StrategyTree[] Solve(ActionTree at, ChanceTree ct, out double[] values) { StrategyTree [] strategies = new StrategyTree[2]; values = new double[2]; for (int heroPos = 0; heroPos < 2; ++heroPos) { strategies[heroPos] = Solve(at, ct, heroPos, out values[heroPos]); if (strategies[heroPos] == null) { return(null); } } return(strategies); }
private static void CreateOppActionTree() { Console.WriteLine("Creating new Opponent action tree from game def: {0} ...", _cmdLine.gameDef); _oppActionTree = new ActionTree(_gameDef, _bucketizer); _oppActionTree.Build(); Console.WriteLine("Opponent action tree created."); // Workaround for disabled Assert dialog DefaultTraceListener trListener = (DefaultTraceListener)Debug.Listeners[0]; trListener.AssertUiEnabled = true; }
public void InitActionTree() { if (!IsValid) { return; } if (ActionTree.InvokeRequired) { ActionTree.BeginInvoke(new GuiInvokeCB(InitActionTreeCallback)); } else { InitActionTreeCallback(); } }
public void Test_LeducHe() { GameDefinition gd = XmlSerializerExt.Deserialize <GameDefinition>( Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/leduc-he.gamedef.xml")); ActionTree ct = CreateActionTreeByGameDef.Create(gd); using (TextWriter w = new StreamWriter(File.Open(Path.Combine(_outDir, "leduc-at.gv"), FileMode.Create))) { VisActionTree vis = new VisActionTree { Output = w }; vis.Show(ct); } }