Merge pull request #2 from michael-kamel/problems/examples

Finalized SaveWesteros

src/HardCodedExamples.txt

@@ -0,0 +1,145 @@
+1
+., O, ., ., ., 
+O, S, O, ., W, 
+O, W, O, ., W, 
+W, ., ., ., ., 
+., ., O, ., J, 
+
+
+2
+O, ., O, ., ., ., 
+., ., W, ., W, O, 
+., O, O, W, W, O, 
+., O, S, ., ., ., 
+., ., ., ., O, ., 
+., ., O, ., ., J, 
+
+
+3
+W, ., ., ., ., ., 
+., ., O, O, O, ., 
+W, O, O, O, O, ., 
+., ., ., S, O, ., 
+., O, O, O, O, W, 
+., ., ., ., ., J,
+
+
+4
+W, O, ., ., ., W, 
+O, ., O, ., ., ., 
+W, O, O, O, O, ., 
+., ., ., S, O, ., 
+., O, O, O, O, W, 
+., ., ., ., ., J,
+
+
+5
+., ., W, ., 
+., W, ., ., 
+O, ., W, O, 
+., O, S, J, 
+
+
+6
+O, O, O, ., W, ., 
+O, O, O, ., O, ., 
+O, O, O, ., O, ., 
+O, O, O, W, O, ., 
+W, O, ., W, O, S, 
+W, W, ., W, W, J, 
+
+
+7
+O, O, O, ., ., ., 
+O, O, O, W, O, ., 
+O, O, O, W, O, ., 
+O, O, O, W, O, W, 
+O, ., ., ., O, S, 
+O, W, ., W, W, J,
+
+
+8
+O, O, ., ., ., 
+O, O, W, O, ., 
+O, O, W, O, ., 
+O, O, W, O, ., 
+O, O, W, O, ., 
+O, ., ., O, S, 
+W, ., W, W, J,
+
+
+9
+O, O, ., ., ., 
+O, O, W, O, ., 
+O, O, W, O, ., 
+O, O, W, O, ., 
+O, O, W, O, ., 
+O, O, W, O, ., 
+O, ., ., O, S, 
+W, ., W, W, J,
+
+
+10
+O, O, ., ., ., 
+O, O, W, O, ., 
+O, O, W, O, ., 
+O, O, W, O, ., 
+O, O, W, O, ., 
+O, O, W, O, ., 
+O, O, W, O, ., 
+O, ., ., O, S, 
+W, ., W, W, J,
+
+
+11
+W, ., ., ., ., ., 
+., O, O, O, O, W, 
+., O, O, O, O, W, 
+W, O, O, O, O, ., 
+., ., O, O, O, S, 
+W, ., W, W, ., J, 
+
+
+12
+S, ., ., ., ., ., 
+., O, O, O, O, W, 
+., O, O, O, O, W, 
+W, O, O, O, O, ., 
+., ., O, O, O, ., 
+W, ., W, W, ., J, 
+
+
+13
+W, ., ., ., W, ., 
+O, W, O, O, O, ., 
+O, W, O, O, O, W, 
+W, ., O, O, O, S, 
+W, ., O, O, O, ., 
+O, ., O, O, O, ., 
+O, W, ., ., W, J,
+
+
+14
+W, ., ., W, S, ., ., ., ., ., ., ., ., ., ., ., ., ., ., ., 
+O, W, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, ., 
+O, W, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, ., 
+W, ., O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, ., 
+O, ., O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, ., 
+O, ., O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, ., 
+O, ., ., ., ., ., ., ., ., ., ., ., ., ., ., ., ., ., ., J,
+
+
+15
+O, ., O, ., ., ., 
+., ., W, ., W, O, 
+., O, O, W, W, O, 
+., O, S, ., ., ., 
+., ., ., ., O, ., 
+., ., O, ., ., J,
+
+
+
+
+
+
+

src/searching/agents/SearchAgent.java

@@ -2,41 +2,41 @@
 
 import java.util.Optional;
 
+import searching.problems.SearchAction;
 import searching.problems.SearchProblem;
-import searching.structs.SearchAction;
-import searching.structs.SearchProblemSolution;
-import searching.structs.SearchTree;
-import searching.structs.SearchTreeNode;
+import searching.problems.SearchProblemSolution;
+import searching.problems.SearchState;
+import searching.strategies.SearchStrategy;
 
-public abstract class SearchAgent {
-	private SearchTree stateTree;
-	private int maxTreeNodes;
+public class SearchAgent<T extends SearchState, V extends SearchAction> {
+	//sets an upper-bound to the number of expanded nodes to avoid running forever
+	private int maxTreeNodes; 
 
 	public SearchAgent(int maxTreeNodes) {
 		this.maxTreeNodes = maxTreeNodes;
 	}
 
-	public SearchProblemSolution search(SearchProblem problem, SearchStrategy searchStrategy) {
+	public SearchProblemSolution<T, V> search(SearchProblem<T, V> problem, SearchStrategy<T, V> searchStrategy) {
+		SearchTreeNode<T, V> rootNode = new SearchTreeNode<T, V>(Optional.empty(), 0, 
+				problem.getInitialState(), Optional.empty(), 0);
+
+		searchStrategy.addNode(rootNode);
+		int count = 0; //number of _expanded_ nodes, so far
 
-		SearchTreeNode rootNode = new SearchTreeNode(Optional.empty(), 0, problem.getInitialState(), SearchAction.NoAction());
-		stateTree.append(rootNode);
-		int count = 0;
 		while(count <= maxTreeNodes) {
-			Optional<SearchTreeNode> nodeToCheck = searchStrategy.getNext();
-
-			if(!nodeToCheck.isPresent())
-				return SearchProblemSolution.Failure();
-
+			//gets the next node; dequeuing/popping (the data structure is strategy-dependent)
+			Optional<SearchTreeNode<T, V>> nodeToCheck = searchStrategy.getNext();  
 
-			if(problem.getGoalTest().isGoal(nodeToCheck.get().getCurrentState()))
-				return new SearchProblemSolution(Optional.of(nodeToCheck.get()));
+			if(!nodeToCheck.isPresent()) //emptied the data structure; no more nodes to expand 
+				return SearchProblemSolution.NoSolution(problem, count); 
 
-			Iterable<SearchTreeNode> nodesToAdd = problem.expand(nodeToCheck.get());
-			searchStrategy.addNodes(nodesToAdd);
+			if(problem.goalTest(nodeToCheck.get().getCurrentState()))
+				return new SearchProblemSolution<T, V>(problem, Optional.of(nodeToCheck.get()), count);
 
-			count++;
+			searchStrategy.addNodes(problem.expand(nodeToCheck.get()));//pushes/queues nodes
+			count++; 
 		}
 
-		throw new UnsupportedOperationException();//change this
+		return SearchProblemSolution.Bottom(problem, count); //when resources are exhausted
 	}
 }

src/searching/agents/SearchTreeNode.java

@@ -0,0 +1,48 @@
+package searching.agents;
+
+import java.util.Optional;
+
+import searching.problems.SearchAction;
+import searching.problems.SearchState;
+
+public class SearchTreeNode<T extends SearchState, V extends SearchAction> implements Comparable<SearchTreeNode<T, V>> {
+	private final Optional<SearchTreeNode<T, V>> parent; //Parent of node
+	private final long cost; // Path cost from the root of the tree until this node
+	private final T state; // The current state of the node
+	private final Optional<V> action; // The action made to reach this node from its parent
+	private final int depth; //depth from root to this node; root depth==0
+
+	public SearchTreeNode(Optional<SearchTreeNode<T, V>> parent, long cost, T state, Optional<V> action, int depth) {
+		this.parent = parent;
+		this.cost = cost;
+		this.state = state;
+		this.action = action;
+		this.depth = depth;
+	}
+
+	public Optional<SearchTreeNode<T, V>> getParent() {
+		return parent;
+	}
+
+	public long getCost() {
+		return cost;
+	}
+
+	public T getCurrentState() {
+		return state;
+	}
+
+	public Optional<V> getAction() {
+		return action;
+	}
+
+	public int getDepth() {
+		return depth;
+	}
+
+	@Override
+	public int compareTo(SearchTreeNode<T, V> node) {
+		return this.cost > node.cost ? 1 : this.cost == node.cost ? 0 : -1;
+	}
+
+}

src/searching/exceptions/GameConstructionConstraintsViolation.java

@@ -0,0 +1,12 @@
+package searching.exceptions;
+/*
+ * used for handling _problem-specific_ constraints
+ * */
+public class GameConstructionConstraintsViolation extends SearchProblemException {
+	private static final long serialVersionUID = 1L;
+
+	public GameConstructionConstraintsViolation(String message) {
+		super(message);
+	}
+
+}

src/searching/exceptions/SearchProblemException.java

@@ -0,0 +1,9 @@
+package searching.exceptions;
+
+public abstract class SearchProblemException extends SearchingException {
+	private static final long serialVersionUID = 1L;
+
+	public SearchProblemException(String message) {
+		super(message);
+	}
+}

src/searching/exceptions/SearchingException.java

@@ -0,0 +1,9 @@
+package searching.exceptions;
+
+public abstract class SearchingException extends Exception {
+	private static final long serialVersionUID = 1L;
+
+	public SearchingException(String message) {
+		super(message);
+	}
+}

src/searching/exceptions/UnknownGameObjectException.java

@@ -0,0 +1,9 @@
+package searching.exceptions;
+
+public class UnknownGameObjectException extends SearchProblemException {
+	private static final long serialVersionUID = 1L;
+
+	public UnknownGameObjectException(String message) {
+		super(message);
+	}
+}

src/searching/problems/HeuristicFunctions.java

@@ -0,0 +1,18 @@
+package searching.problems;
+
+import searching.strategies.HeuristicFunction;
+
+public class HeuristicFunctions {
+	/**
+	 * a function that calculates the dominant of two heuristic functions
+	 * @param first 
+	 * @param second
+	 * @return {@link HeuristicFunction}
+	 */
+	public static <T extends SearchState> HeuristicFunction<T> dominating(HeuristicFunction<T> first, 
+			HeuristicFunction<T> second) {
+		return state -> {
+			return Math.max(first.expectedCostToSolution(state), second.expectedCostToSolution(state));
+		};
+	}
+}

src/searching/problems/SearchAction.java

@@ -0,0 +1,3 @@
+package searching.problems;
+
+public interface SearchAction {}