public void Effect(Ws world) { // apply effects wot the worldstate passed in foreach (Wstates W in Enum.GetValues(typeof(Wstates))) { if (world.states[W].Value) { states[W].Value = true; } } }
private Node GetMatchingNodeInVisited(Ws ws) { foreach (Node n in visitedNodes) { if (n.world.Equal(ws)) { return(n); } } return(null); }
private Node GetMatchingNodeInConsidered(Ws ws) { foreach (Node n in considerNodes) { if (n.world.Equal(ws)) { return(n); } } return(null); }
public bool Equal(Ws WS) { foreach (Wstates w in Enum.GetValues(typeof(Wstates))) { if (states[w].Value != WS.states[w].Value)// cheack that the world state value is equal to its orginal value { return(false); } } return(true); }
private List <Action> GetPossibleTransitions(Ws from, ref List <Ws> tos) { List <Action> transitions = new List <Action>(); foreach (Action a in actions) { if (from.PreConditionsMeet(a.preConditions)) { transitions.Add(a); tos.Add(from.GetWSEffected(a.effects)); } } return(transitions); }
public bool EnabledEqual(Ws WS) { foreach (Wstates w in Enum.GetValues(typeof(Wstates))) { if (WS.states[w].IsEnabled)// cheak that the world state is enabled variable is equal to is orginal value { if (states[w].Value != WS.states[w].Value) { return(false); } } } return(true); }
public int GetNumMisMatchStates(Ws world) { int mis = 0; foreach (Wstates w in Enum.GetValues(typeof(Wstates))) { if (world.states[w].IsEnabled) // gain the number of states that do not match their original value { if (states[w].Value != world.states[w].Value) { mis++; } } } return(mis); }
public Ws GetWSEffected(Ws effects) { Ws worldstate = new Ws(); foreach (Wstates w in Enum.GetValues(typeof(Wstates))) // for each of the worldstates assign the effed world states { worldstate.states[w].Value = states[w].Value; worldstate.states[w].IsEnabled = states[w].IsEnabled; } foreach (Wstates w in Enum.GetValues(typeof(Wstates))) { if (effects.states[w].Value) // if the world state value is true assign the variables for the worldstate to true { worldstate.states[w].Value = true; worldstate.states[w].IsEnabled = true; } } return(worldstate); }
public Stack <Action> GetPlan(Ws start, Goal currentGoal) { considerNodes.Clear(); visitedNodes.Clear(); Ws goal = currentGoal.condition; // Create a Node to encapsualte the start World State Node n0 = new Node(); n0.world = start; n0.parentWorlds = start; // Cost to get to this node from start n0.g = 0; // A guess as to how far we are from the goal n0.h = start.GetNumMisMatchStates(goal); // Guess of overall cost from start to goal n0.f = n0.g + n0.h; // The Action associated with the Node n0.action = null; // Add the Node to consider considerNodes.Add(n0); do { if (considerNodes.Count == 0) { Debug.Log("Did not find a path"); return(null); } // Search Open List for Node with the lowest guested cost (closest to Goal). int lowestVal = 100000; Node lowestNode = null; foreach (Node n in considerNodes) { if (n.f < lowestVal) { lowestVal = n.f; lowestNode = n; } } // Set the lowest cost Node as the current Node Node currentNode = lowestNode; // Remove Node considerNodes.Remove(lowestNode); // If the current Node's World State match the Goal we are finished if (currentNode.world.HasAchived(goal)) { return(ReconstructPlan(currentNode)); } // Add Current Node to visited List visitedNodes.Add(currentNode); List <Ws> tos = new List <Ws>(); List <Action> transitionActions = GetPossibleTransitions(currentNode.world, ref tos); int index = 0; // For each of currents Node's adjacent Actions foreach (Action a in transitionActions) { // Get the Actions World State after effects have been applied Ws to = tos[index]; index++; // Calcuate the cost from current to the completed adjacent Action int cost = currentNode.g + a.Cost; // The Node may already be under consideration Node openNode = GetMatchingNodeInConsidered(to); // The Node may already have been processed Node closedNode = GetMatchingNodeInVisited(to); // If already under consideration check the cost as it may be cheaper coming via this route if (openNode != null && cost < openNode.g) { considerNodes.Remove(openNode); // Force the Node to be created openNode = null; } // if the Node has been visited check the cost as it may be cheaper coming via this route if (closedNode != null && cost < closedNode.g) { visitedNodes.Remove(closedNode); } // If adjacent Action not in visited or considered Lists if (openNode == null && closedNode == null) { // Ecapsulate the adjacent Action in a Node Node nb = new Node(); // The World State after Action effects are applied nb.world = to; nb.g = cost; // Number of mismatched Atoms between goal and current Node. // A heuristic (guess) measure to how close we are to Goal. nb.h = nb.world.GetNumMisMatchStates(goal); nb.f = nb.g + nb.h; nb.action = a; // The World State before Action effects were applied // This allows us to trace our way back to the start nb.parentWorlds = currentNode.world; // Add Node to List for consideration considerNodes.Add(nb); } } } while (true); }
public Goal(int priority) { m_priority = priority; condition = new Ws(); }
public bool PreConditionsMeet(Ws cond) { return(EnabledEqual(cond)); //return if the world state is equal }
public bool HasAchived(Ws GL) { return(EnabledEqual(GL)); // return if the world state is equal }