public State GetSuccessorSuperposition(MediationTreeEdge edge)
{
VirtualMediationTreeNode parent = GetNode(edge.Parent) as VirtualMediationTreeNode;
Superposition pred = parent.State as Superposition;
Superposition super = new Superposition();
if (edge is VirtualMediationTreeEdge)
{
VirtualMediationTreeEdge vEdge = edge as VirtualMediationTreeEdge;
foreach (State state in pred.States)
{
foreach (Operator action in vEdge.Actions)
{
if (state.Satisfies(action.Preconditions))
{
super.States.Add(state.NewState(action, data.problem.Objects));
}
}
}
}
else
{
foreach (State state in pred.States)
{
if (state.Satisfies(edge.Action.Preconditions))
{
super.States.Add(state.NewState(edge.Action as Operator, data.problem.Objects));
}
}
}
return(super);
}
protected override void UpdatePlan()
{
if (incoming != null)
{
if (incoming.ActionType.Equals(ActionType.Exceptional))
{
Superposition super = state as Superposition;
foreach (State current in super.States)
{
plan = PlannerInterface.Plan(Planner.FastDownward, domain, GetProblem(current));
if (plan.Steps.Count > 0)
{
return;
}
}
}
else if (incoming.ActionType.Equals(ActionType.Constituent))
{
plan = plan.GetPlanUpdate(problem, incoming.Action as Operator);
}
}
else
{
Superposition super = state as Superposition;
foreach (State current in super.States)
{
plan = PlannerInterface.Plan(Planner.FastDownward, domain, GetProblem(current));
if (plan.Steps.Count > 0)
{
return;
}
}
}
}
public VirtualMediationTreeNode(Domain domain, Problem problem, MediationTreeEdge incoming, State state, Plan plan, int id, int depth)
{
this.domain = domain;
this.incoming = incoming;
this.id = id;
this.state = state.Clone() as State;
this.depth = depth;
this.plan = plan;
// Create and populate a problem object based on the new file.
this.problem = new Problem("rob", problem.OriginalName, problem.Domain, problem.Player, problem.Objects, this.state.Predicates, problem.Intentions, problem.Goal);
outgoing = new List <MediationTreeEdge>();
Superposition super = state as Superposition;
satisfiesGoal = false;
foreach (State st in super.States)
{
if (st.Satisfies(problem.Goal))
{
satisfiesGoal = true;
break;
}
}
UpdatePlan();
}
/// <summary>
/// Returns a list of outgoing edges for a given node.
/// </summary>
/// <param name="node">The node object.</param>
/// <param name="actor">The name of the current actor.</param>
/// <returns>A list of outgoing edges.</returns>
public List <MediationTreeEdge> GetOutgoingEdges(MediationTreeNode node, string actor)
{
List <MediationTreeEdge> outgoing = StateSpaceTools.GetAllPossibleActions(actor, node);
if (!data.superpositionManipulation)
{
return(outgoing);
}
List <MediationTreeEdge> unobservedActions = new List <MediationTreeEdge>();
List <MediationTreeEdge> observedActions = new List <MediationTreeEdge>();
foreach (MediationTreeEdge edge in outgoing)
{
Superposition super = node.State as Superposition;
bool obs = false;
foreach (State state in super.States)
{
if (state.Satisfies(edge.Action.Preconditions))
{
if (KnowledgeAnnotator.Observes(Player, edge.Action, state.Predicates))
{
observedActions.Add(edge);
obs = true;
break;
}
}
}
if (!obs)
{
unobservedActions.Add(edge);
}
}
if (unobservedActions.Count > 0)
{
VirtualMediationTreeEdge super = new VirtualMediationTreeEdge();
foreach (MediationTreeEdge unobserved in unobservedActions)
{
super.Actions.Add(unobserved.Action as Operator);
}
super.Parent = node.ID;
observedActions.Add(super);
}
return(observedActions);
}
/// <summary>
/// Collapses the superposition given the player, the current tree node, and a strategy for choosing between unique state sets
/// </summary>
/// <param name="player">The player's name.</param>
/// <param name="node">The current tree node.</param>
/// <param name="chooser">A strategy for choosing between perceptually unique state sets.</param>
/// <returns>A state superposition.</returns>
public static HashSet <State> Collapse(string player, VirtualMediationTreeNode node, SuperpositionChooser.Choose chooser)
{
// Store the node's state as a superposition structure.
Superposition super = node.State as Superposition;
// Check to see if the node has more than one superposed state.
if (super.States.Count > 0)
{
// Create a dictionary that maps sets of observed literals to sets of states that match the observation.
Dictionary <List <IPredicate>, HashSet <State> > obs = new Dictionary <List <IPredicate>, HashSet <State> >(new PredicateListComparer());
// Iterate through each state in the superposition.
foreach (State state in super.States)
{
// Find and store the set of literals observed by the player in the current state.
List <IPredicate> observed = KnowledgeAnnotator.FullKnowledgeState(node.Domain.Predicates, node.Problem.ObjectsByType, state.Predicates, player);
// If the current set of literals has been encountered before, add the state to its set.
if (obs.ContainsKey(observed))
{
obs[observed].Add(state);
}
// Otherwise, create a new dictionary key for the set of observed literals and initialize the state set with the current state.
else
{
obs.Add(observed, new HashSet <State> {
state
});
}
}
// Choose a set of states from the superposition according to the given strategy and return it.
return(chooser(obs, node));
}
// Return the empty set of states.
return(super.States);
}
/// <summary>
/// Allows custom plans to be passed in.
/// </summary>
/// <param name="domain">The node's domain.</param>
/// <param name="problem">The node's problem.</param>
/// <param name="incoming">The node's incoming edge.</param>
/// <returns>A new tree node.</returns>
private MediationTreeNode CreateNode(Domain domain, Problem problem, MediationTreeEdge incoming, Plan plan)
{
// Create a placeholder for the new node object.
MediationTreeNode node = null;
// If the node is a root, initialize a root node.
if (incoming == null)
{
if (!data.superpositionManipulation)
{
node = new MediationTreeNode(domain, problem, 0);
}
else
{
node = new VirtualMediationTreeNode(domain, problem, 0);
}
}
// Otherwise, it is a child node...
else
{
// Store the current node's ID in the incoming edge.
incoming.Child = ++data.nodeCounter;
if (!data.superpositionManipulation)
{
node = new MediationTreeNode(domain, problem, incoming, GetSuccessorState(incoming), plan, incoming.Child, GetDepth(incoming.Parent) + 1);
}
else
{
node = new VirtualMediationTreeNode(domain, problem, incoming, GetSuccessorSuperposition(incoming), plan, incoming.Child, GetDepth(incoming.Parent) + 1);
}
// Add the edge to the tree hashtable.
data.tree[incoming.Child] = incoming.Parent;
MediationTreeNode parent = GetNode(incoming.Parent);
if (incoming.Action != null)
{
parent.Outgoing.Find(x => x.Action.Equals(incoming.Action)).Child = node.ID;
}
else
{
foreach (MediationTreeEdge edge in parent.Outgoing)
{
if (edge is VirtualMediationTreeEdge)
{
if ((edge as VirtualMediationTreeEdge).Equals(incoming as VirtualMediationTreeEdge))
{
edge.Child = node.ID;
}
}
}
}
SetNode(parent);
if (data.superpositionManipulation)
{
Superposition super = node.State as Superposition;
super.States = SuperpositionManipulator.Collapse(data.player, node as VirtualMediationTreeNode, SuperpositionChooser.ChooseUtility);
node.State = super;
}
}
// If the node is a goal state, iterate the goal state counter.
if (node.IsGoal)
{
data.goalStateCount++;
}
// If the node is a dead end, iterate the dead end counter.
if (node.DeadEnd)
{
if (data.eventRevision)
{
EventRevisor.EventRevision(Planner.FastDownward, node, this);
}
if (node.DeadEnd && data.domainRevision)
{
DomainRevisor.DomainRevision(Planner.FastDownward, node, this);
}
if (node.DeadEnd)
{
data.deadEndCount++;
}
}
// If the node is at a lower depth than the previous record holder, update the depth counter.
if (node.Depth > data.lowestDepth)
{
data.lowestDepth = node.Depth;
}
// If the node is not a dead end.
if (!node.DeadEnd)
{
// Find and store the node's outgoing edges.
node.Outgoing = GetOutgoingEdges(node, GetCurrentTurn(node));
}
// Save the current node to disk.
SetNode(node);
// Return the current node object.
return(node);
}