public void Deserialize()
{
GroundActionFactory.GroundActions = new List <IOperator>();
GroundActionFactory.GroundLibrary = new Dictionary <int, IOperator>();
foreach (var file in Directory.GetFiles(Parser.GetTopDirectory() + @"Cached\CachedOperators\", testDomainName + "_" + testProblem.Name + "*.CachedOperator"))
{
var op = BinarySerializer.DeSerializeObject <IOperator>(file);
GroundActionFactory.GroundActions.Add(op);
GroundActionFactory.GroundLibrary[op.ID] = op;
}
// THIS is so that initial and goal steps created don't get matched with these
Operator.SetCounterExternally(GroundActionFactory.GroundActions.Count + 1);
Console.WriteLine("Finding Statics");
GroundActionFactory.DetectStatics();
foreach (var stat in GroundActionFactory.Statics)
{
Console.WriteLine(stat);
}
//Console.WriteLine("\nCmap\n");
//var cmap = BinarySerializer.DeSerializeObject<TupleMap<IPredicate, List<int>>>(CausalMapFileName + ".CachedCausalMap");
//CacheMaps.CausalTupleMap = cmap;
//Console.WriteLine("\nTmap\n");
//var tcmap = BinarySerializer.DeSerializeObject<TupleMap<IPredicate, List<int>>>(ThreatMapFileName + ".CachedThreatMap");
//CacheMaps.ThreatTupleMap = tcmap;
}
public void Deserialize()
{
GroundActionFactory.GroundActions = new List <IOperator>();
GroundActionFactory.GroundLibrary = new Dictionary <int, IOperator>();
foreach (var file in Directory.GetFiles(Parser.GetTopDirectory() + @"Cached\CachedOperators\", testDomainName + "_" + testProblem.Name + "*.CachedOperator"))
{
var op = BinarySerializer.DeSerializeObject <IOperator>(file);
GroundActionFactory.GroundActions.Add(op);
GroundActionFactory.GroundLibrary[op.ID] = op;
}
// THIS is so that initial and goal steps created don't get matched with these
Operator.SetCounterExternally(GroundActionFactory.GroundActions.Count + 1);
}
/// <summary>
/// The base constructor.
/// </summary>
/// <param name="planner">The planner to use.</param>
/// <param name="domain">The base domain object.</param>
/// <param name="problem">The base problem object.</param>
/// <param name="path">The path used to save files to disk.</param>
/// <param name="domainRevision">Whether to use domain revision.</param>
/// <param name="eventRevision">Whether to use event revision.</param>
/// <param name="superpositionManipulation">Whether to use superposition manipulation.</param>
public MediationTree(Domain domain, Problem problem, string path, bool domainRevision, bool eventRevision, bool superpositionManipulation)
{
// Set the path.
this.path = path;
// Check each path to see if it exists. If not, create the folder.
if (!File.Exists(path))
{
Directory.CreateDirectory(path);
}
// If data already exists, load it from memory.
if (File.Exists(path + "mediationtree"))
{
data = BinarySerializer.DeSerializeObject <MediationTreeData>(path + "mediationtree");
}
// Otherwise, initialize a new tree.
else
{
data.eventRevision = eventRevision;
data.domainRevision = domainRevision;
data.superpositionManipulation = superpositionManipulation;
// Store the domain and problem.
data.domain = domain;
data.problem = problem;
// Store the player's name.
data.player = problem.Player.ToLower();
// Get and store the NPC names.
data.npcs = GetNPCs();
// Establish the turn order.
data.turnOrder = GetTurnOrder();
// Create a new hashtable to store tree edges.
data.tree = new Hashtable();
// Initialize the session counters.
data.nodeCounter = 0;
data.lowestDepth = 0;
data.goalStateCount = 0;
data.deadEndCount = 0;
// Create the tree's root node.
MediationTreeNode root = CreateNode(domain, problem, null);
}
}
public void DecacheSteps()
{
Parser.path = @"D:\documents\frostbow\";
var FileName = GetFileName();
GroundActionFactory.GroundActions = new List <IOperator>();
GroundActionFactory.GroundLibrary = new Dictionary <int, IOperator>();
foreach (var file in Directory.GetFiles(Parser.GetTopDirectory() + @"Cached\CachedOperators\UnityBlocksWorld\", problemname + "*.CachedOperator"))
{
var op = BinarySerializer.DeSerializeObject <IOperator>(file);
GroundActionFactory.GroundActions.Add(op);
GroundActionFactory.GroundLibrary[op.ID] = op;
}
// THIS is so that initial and goal steps created don't get matched with these
Operator.SetCounterExternally(GroundActionFactory.GroundActions.Count + 1);
}
public static void Deserialize(string directory)
{
GroundActionFactory.GroundActions = new List <IOperator>();
GroundActionFactory.GroundLibrary = new Dictionary <int, IOperator>();
foreach (var file in Directory.GetFiles(directory + "*.CachedOperator"))
{
var op = BinarySerializer.DeSerializeObject <IOperator>(file);
GroundActionFactory.GroundActions.Add(op);
GroundActionFactory.GroundLibrary[op.ID] = op;
}
// THIS is so that initial and goal steps created don't get matched with these
Operator.SetCounterExternally(GroundActionFactory.GroundActions.Count + 1);
Console.WriteLine("Finding Statics");
GroundActionFactory.DetectStatics();
foreach (var stat in GroundActionFactory.Statics)
{
Console.WriteLine(stat);
}
}
public void DecacheSteps()
{
Parser.path = @"D:\documents\frostbow\";
var FileName = GetFileName();
GroundActionFactory.GroundActions = new List <IOperator>();
GroundActionFactory.GroundLibrary = new Dictionary <int, IOperator>();
int maxSeen = 0;
int maxStepSeen = 0;
foreach (var file in Directory.GetFiles(Parser.GetTopDirectory() + @"Cached\CachedOperators\UnityBlocksWorld\", problemname + "*.CachedOperator"))
{
var op = BinarySerializer.DeSerializeObject <IOperator>(file);
GroundActionFactory.GroundActions.Add(op);
GroundActionFactory.GroundLibrary[op.ID] = op;
if (op.ID > maxSeen)
{
maxSeen = op.ID;
}
if (op is IComposite comp)
{
foreach (var sub in comp.SubSteps)
{
if (sub.ID > maxStepSeen)
{
maxStepSeen = sub.ID;
}
}
if (comp.GoalStep.ID > maxStepSeen)
{
maxStepSeen = comp.GoalStep.ID;
}
}
}
// THIS is so that initial and goal steps created don't get matched with these
Operator.SetCounterExternally(maxSeen + 1);
PlanStep.SetCounterExternally(maxStepSeen + 1);
}
public void DeCacheIt()
{
Parser.path = @"D:\documents\frostbow\";
DecacheSteps();
UnityPlanningInterface.AddObservedNegativeConditions(UPC);
var CausalMapFileName = GetCausalMapFileName();
var ThreatMapFileName = GetThreatMapFileName();
var EffortMapFileName = GetEffortDictFileName();
try
{
var cmap = BinarySerializer.DeSerializeObject <TupleMap <IPredicate, List <int> > >(CausalMapFileName + ".CachedCausalMap");
CacheMaps.CausalTupleMap = cmap;
var tcmap = BinarySerializer.DeSerializeObject <TupleMap <IPredicate, List <int> > >(ThreatMapFileName + ".CachedThreatMap");
CacheMaps.ThreatTupleMap = tcmap;
try
{
var emap = BinarySerializer.DeSerializeObject <TupleMap <IPredicate, int> >(EffortMapFileName + ".CachedEffortMap");
HeuristicMethods.visitedPreds = emap;
}
catch
{
CacheMaps.CacheAddReuseHeuristic(new State(UPC.initialPredicateList) as IState);
UnityGroundActionFactory.PrimaryEffectHack(new State(UPC.initialPredicateList) as IState);
}
}
catch
{
CacheMaps.CacheLinks(GroundActionFactory.GroundActions);
CacheMaps.CacheGoalLinks(GroundActionFactory.GroundActions, UPC.goalPredicateList);
CacheMaps.CacheAddReuseHeuristic(new State(UPC.initialPredicateList) as IState);
UnityGroundActionFactory.PrimaryEffectHack(new State(UPC.initialPredicateList) as IState);
}
}
/// <summary>
/// Read a node object from disk.
/// </summary>
/// <param name="nodeID">The node's ID.</param>
/// <returns>The node object.</returns>
public MediationTreeNode GetNode(int nodeID)
{
// Given the path and ID, deserializes the object from disk.
return(BinarySerializer.DeSerializeObject <MediationTreeNode>(path + nodeID));
}
// Use this for initialization
void Start()
{
var testDomainName = "batman";
var testDomainDirectory = Parser.GetTopDirectory() + @"Benchmarks\" + testDomainName + @"\domain.pddl";
var testDomain = Parser.GetDomain(Parser.GetTopDirectory() + @"Benchmarks\" + testDomainName + @"\domain.pddl", PlanType.PlanSpace);
var testProblem = Parser.GetProblem(Parser.GetTopDirectory() + @"Benchmarks\" + testDomainName + @"\prob01.pddl");
string FileName = Parser.GetTopDirectory() + @"Test\" + testDomainName + "_" + testProblem.Name;
string CausalMapFileName = Parser.GetTopDirectory() + @"CausalMaps\" + testDomainName + "_" + testProblem.Name;
string ThreatMapFileName = Parser.GetTopDirectory() + @"CausalMaps\" + testDomainName + "_" + testProblem.Name;
if (RELOAD)
{
Debug.Log("Creating Ground Operators");
GroundActionFactory.PopulateGroundActions(testDomain.Operators, testProblem);
//BinarySerializer.SerializeObject(FileName, GroundActionFactory.GroundActions);
foreach (var op in GroundActionFactory.GroundActions)
{
BinarySerializer.SerializeObject(FileName + op.GetHashCode().ToString(), op);
}
CacheMaps.CacheLinks(GroundActionFactory.GroundActions);
CacheMaps.CacheGoalLinks(GroundActionFactory.GroundActions, testProblem.Goal);
BinarySerializer.SerializeObject(CausalMapFileName, CacheMaps.CausalMap);
BinarySerializer.SerializeObject(ThreatMapFileName, CacheMaps.ThreatMap);
}
else
{
List <IOperator> Operators = new List <IOperator>();
foreach (string file in Directory.GetFiles(Parser.GetTopDirectory() + @"Cache\" + testDomainName))
{
var op = BinarySerializer.DeSerializeObject <IOperator>(file);
Operators.Add(op);
//string contents = File.ReadAllText(file);
}
//var actions = new List<IOperator>();
GroundActionFactory.GroundActions = Operators;
}
Debug.Log("Caching Maps");
Debug.Log("Finding static preconditions");
GroundActionFactory.DetectStatics(CacheMaps.CausalMap, CacheMaps.ThreatMap);
Debug.Log("Creating initial Plan");
// Create Initial Plan
// public Plan(List<IOperator> steps, IState initial, IState goal, Graph<IOperator> og, ICausalLinkGraph clg, Flawque flawQueue)
// IState _initial, IState _goal, List<IOperator> _steps
var initialPlan = new Plan(new State(testProblem.Initial) as IState, new State(testProblem.Goal) as IState);
foreach (var goal in testProblem.Goal)
{
initialPlan.Flaws.Insert(initialPlan, new OpenCondition(goal, initialPlan.GoalStep as IOperator));
}
Debug.Log("Insert First Ordering");
initialPlan.Orderings.Insert(initialPlan.InitialStep, initialPlan.GoalStep);
Debug.Log("First POP");
var AStarPOP = new PlanSpacePlanner(initialPlan, SearchType.BestFirst, new AddReuseHeuristic().Heuristic);
var bestFirstSolutions = AStarPOP.Solve(1, 6000f);
Debug.Log(bestFirstSolutions[0]);
var BFSPOP = new PlanSpacePlanner(initialPlan, SearchType.BFS, new ZeroHeuristic().Heuristic);
var BFSSolutions = BFSPOP.Solve(1, 6000f);
Debug.Log(BFSSolutions[0]);
var DFSPOP = new PlanSpacePlanner(initialPlan, SearchType.DFS, new ZeroHeuristic().Heuristic);
var DFSSolutions = DFSPOP.Solve(1, 6000f);
Debug.Log(DFSSolutions[0]);
}
// Creates a single tree of specified depth without specifying a folder name.
public static void BreadthFirst(string domainName, int endDepth, bool domainRevision, bool eventRevision, bool superposition)
{
string modifier = "vanilla";
if (domainRevision && eventRevision)
{
modifier = "domain-event";
}
else if (domainRevision)
{
modifier = "domain";
}
else if (eventRevision)
{
modifier = "event";
}
else if (superposition)
{
modifier = "superposition";
}
// Parse the domain file.
Domain domain = Parser.GetDomain(Parser.GetTopDirectory() + @"Benchmarks\" + domainName + @"\domain.pddl", PlanType.StateSpace);
// Parse the problem file.
Problem problem = Parser.GetProblemWithTypes(Parser.GetTopDirectory() + @"Benchmarks\" + domainName + @"\prob01.pddl", domain);
// Create the initial node of mediation space.
MediationTree tree = new MediationTree(domain, problem, Parser.GetTopDirectory() + @"MediationTrees\Data\" + domain.Name + @"\" + modifier + @"\", domainRevision, eventRevision, superposition);
// Remember the game tree path.
string dataPath = Parser.GetTopDirectory() + @"TestLogs\Level\" + domainName + @"\" + modifier + @"\";
// Check each path to see if it exists. If not, create the folder.
if (!File.Exists(dataPath))
{
Directory.CreateDirectory(dataPath);
}
TestData data = new TestData();
Stopwatch watch = new Stopwatch();
Console.WriteLine("Creating a " + modifier + " tree to level " + endDepth);
// If data already exists, load it from memory.
if (File.Exists(dataPath + "mediationtreedata"))
{
data = BinarySerializer.DeSerializeObject <TestData>(dataPath + "mediationtreedata");
}
else
{
data.elapsedMilliseconds = 0;
data.frontier = new List <int>()
{
0
};
data.depth = 0;
data.nodeCounter = 1;
data.goalStateCount = 0;
data.deadEndCount = 0;
data.summarySkip = 1000;
data.summaries = new List <List <Tuple <string, string> > >();
}
Console.WriteLine("Beginning at level " + data.depth);
Console.WriteLine("Beginning at node number " + data.nodeCounter);
watch.Start();
while (endDepth - data.depth > 0 && data.frontier.Count > 0)
{
MediationTreeNode current = tree.GetNode(data.frontier[0]);
foreach (MediationTreeEdge edge in current.Outgoing)
{
bool newDepth = false;
MediationTreeNode child = tree.GetNode(current.Domain, current.Problem, edge);
if (child.Depth > data.depth)
{
data.depth = child.Depth;
newDepth = true;
Console.WriteLine("Reached level " + data.depth);
}
data.nodeCounter++;
if (child.IsGoal)
{
data.goalStateCount++;
}
if (child.DeadEnd)
{
data.deadEndCount++;
}
data.frontier.Add(child.ID);
watch.Stop();
if (newDepth)
{
data.summaries.Add(CreateSummary(data));
}
watch.Start();
}
data.frontier.RemoveAt(0);
data.elapsedMilliseconds += watch.ElapsedMilliseconds;
watch.Reset();
BinarySerializer.SerializeObject <TestData>(dataPath + "mediationtreedata", data);
if (data.nodeCounter % 1000 == 0)
{
Console.WriteLine("Reached node number " + data.nodeCounter);
}
watch.Start();
}
watch.Stop();
int size = data.summaries.Count + 1;
BinarySerializer.SerializeObject <TestData>(dataPath + "mediationtreedata", data);
WriteSummary(@"\Level\" + domainName + @"\" + modifier, data.nodeCounter.ToString(), data.summaries);
if (data.summaries.Count > 0)
{
Grapher.CreateGraphs(domainName, data.nodeCounter.ToString(), size, dataPath, data.summaries);
}
}
// Creates a single tree of specified depth without specifying a folder name.
public static void MCTSearch(string domainName, int totalPlays, int interval)
{
// Save the summaries of each build.
List <List <Tuple <String, String> > > summaries = new List <List <Tuple <String, String> > >();
// Remember a time stamp for the top directory.
string timeStamp = DateTime.Now.ToString("MM-dd-yyyy-HH-mm-tt");
// Read in the domain file.
Domain domain = Parser.GetDomain(Parser.GetTopDirectory() + @"Benchmarks\" + domainName + @"\domain.pddl", PlanType.StateSpace);
// Read in the problem file.
Problem problem = Parser.GetProblemWithTypes(Parser.GetTopDirectory() + @"Benchmarks\" + domainName + @"\prob01.pddl", domain);
// Create a stopwatch object.
Stopwatch watch = new Stopwatch();
// Remember the game tree path.
string path = Parser.GetTopDirectory() + @"GameTrees\Data\" + domainName + @"\";
// Check each path to see if it exists. If not, create the folder.
if (!File.Exists(path))
{
Directory.CreateDirectory(path);
}
// Start the stopwatch.
watch.Start();
// Initialize the game tree.
GameTree tree = null;
if (File.Exists(path + "gametree"))
{
tree = BinarySerializer.DeSerializeObject <GameTree>(path + "gametree");
}
else
{
tree = new GameTree(domain, problem, path);
}
// Stop the stopwatch.
watch.Stop();
// Loop through the depths.
for (int plays = 0; plays < totalPlays; plays = plays + interval)
{
Console.Out.WriteLine("Starting play " + plays);
// Print the current tree.
summaries.Add(WriteTree(domainName, timeStamp, plays, watch, tree, false));
// Start the watch.
watch.Start();
// Play the next round.
MCTS.Search(interval, tree);
// Save the game tree.
BinarySerializer.SerializeObject <GameTree>(path + "gametree", tree);
// Stop the watch.
watch.Stop();
}
Console.Out.WriteLine("Printing tree.");
// Print the current tree.
summaries.Add(WriteTree(domainName, timeStamp, totalPlays, watch, tree, false));
// Write the summary CSV file to disk.
WriteGTSummary(domainName, timeStamp, summaries);
// Use the CSV file to create an Excel spreadsheet and graphs of each summary element.
Grapher.CreateGTGraphs(domainName, timeStamp, (totalPlays / interval) + 2, summaries);
}
