Some refactoring performed to improve code structure.

- Map renamed to ExtendableMap.
- New interface Map added.
- Class Point2D added to encapsulate location position information.
- AbstractMapAgentModel merged into MapAgentModel.

Author: Ruediger.Lunde

src/aima/gui/applications/search/map/AbstractMapAgentController.java

@@ -33,7 +33,7 @@ public abstract class AbstractMapAgentController extends AgentAppController {
 	/** Clears the model's tour history. */
 	@Override
 	public void clearAgent() {
-		((AbstractMapAgentModel) model).clearTourHistory();
+		((MapAgentModel) model).clearTourHistory();
 		frame.modelChanged();
 	}
 

src/aima/gui/applications/search/map/AbstractMapAgentModel.java

@@ -8,6 +8,7 @@
 import aima.gui.framework.AgentView;
 import aima.search.framework.SearchFactory;
 import aima.search.map.Map;
+import aima.search.map.Point2D;
 
 
 /**
@@ -60,7 +61,7 @@ class MapAgentView extends AgentView {
 
 		/** Clears the panel and draws the map and the tour history. */
 		public void paint(java.awt.Graphics g) {
-			AbstractMapAgentModel maModel = (AbstractMapAgentModel) model;
+			MapAgentModel maModel = (MapAgentModel) model;
 		    java.awt.Graphics2D g2 = (java.awt.Graphics2D) g;
 		    g2.setColor(Color.white);
 		    g2.fillRect(0, 0, getWidth(), getHeight());
@@ -78,19 +79,19 @@ public void paint(java.awt.Graphics g) {
 		 * view without scrolling.
 		 */
 		private void adjustTransformation() {
-			AbstractMapAgentModel maModel = (AbstractMapAgentModel) model;
+			MapAgentModel maModel = (MapAgentModel) model;
 			List<String> locs = maModel.getLocations();
 	    	// adjust coordinates relative to the left upper corner of the graph area
 	    	double minX = Double.POSITIVE_INFINITY;
 	    	double minY = Double.POSITIVE_INFINITY;
 	    	double maxX = Double.NEGATIVE_INFINITY;
 	    	double maxY = Double.NEGATIVE_INFINITY;
 	    	for (String loc : locs) {
-	    		double[] xy = maModel.getLocCoords(loc);
-	    		if (xy[0] < minX) minX = xy[0];
-	    		if (xy[1] < minY) minY = xy[1];
-	    		if (xy[0] > maxX) maxX = xy[0];
-	    		if (xy[1] > maxY) maxY = xy[1];
+	    		Point2D xy = maModel.getLocCoords(loc);
+	    		if (xy.getX() < minX) minX = xy.getX();
+	    		if (xy.getY() < minY) minY = xy.getY();
+	    		if (xy.getX() > maxX) maxX = xy.getX();
+	    		if (xy.getY() > maxY) maxY = xy.getY();
 	    	}
 	    	this.setBorder(20, 20, 20, 100);
 	    	adjustTransformation(minX, minY, maxX, maxY);
@@ -100,31 +101,31 @@ private void adjustTransformation() {
 		 * Represents roads by lines and locations by name-labeled points.
 		 */
 		private void paintMap(java.awt.Graphics2D g2) {
-			AbstractMapAgentModel maModel = (AbstractMapAgentModel) model;
+			MapAgentModel maModel = (MapAgentModel) model;
 			Map envMap = maModel.getEnvMap();
 			Map agentMap = maModel.getAgentMap();
 			List<Roadblock> roadblocks = new ArrayList<Roadblock>();
 			for (String l1 : maModel.getLocations()) {
-				double[] xy1 = maModel.getLocCoords(l1);
+				Point2D pt1 = maModel.getLocCoords(l1);
 				List<String> linkedLocs = envMap.getLocationsLinkedTo(l1);
 				for (String l2 : agentMap.getLocationsLinkedTo(l1))
 					if (!linkedLocs.contains(l2))
 						linkedLocs.add(l2);
 				for (String l2 : linkedLocs) {
-					double[] xy2 = maModel.getLocCoords(l2);
+					Point2D pt2 = maModel.getLocCoords(l2);
 					g2.setColor(Color.lightGray);
-		    		g2.drawLine(x(xy1), y(xy1), x(xy2), y(xy2));
+		    		g2.drawLine(x(pt1), y(pt1), x(pt2), y(pt2));
 		    		boolean blockedInEnv =
 		    			!envMap.getLocationsLinkedTo(l2).contains(l1);
 		    		boolean blockedInAgent =
 		    			!agentMap.getLocationsLinkedTo(l2).contains(l1);
-		    		roadblocks.add(new Roadblock(xy1, xy2, blockedInEnv, blockedInAgent));
+		    		roadblocks.add(new Roadblock(pt1, pt2, blockedInEnv, blockedInAgent));
 		    		if (blockedInEnv && blockedInAgent) {
 		    			boolean blockedInEnvOtherDir =
 			    			!envMap.getLocationsLinkedTo(l1).contains(l2);
 		    			boolean blockedInAgentOtherDir =
 			    			!agentMap.getLocationsLinkedTo(l1).contains(l2);
-		    			roadblocks.add(new Roadblock(xy2, xy1, blockedInEnvOtherDir, blockedInAgentOtherDir));
+		    			roadblocks.add(new Roadblock(pt2, pt1, blockedInEnvOtherDir, blockedInAgentOtherDir));
 		    		}
 				}
 			}
@@ -134,15 +135,15 @@ private void paintMap(java.awt.Graphics2D g2) {
 
 		/** The track of the agent is visualized with red lines. */
 		private void paintTour(java.awt.Graphics2D g2) {
-			AbstractMapAgentModel maModel = (AbstractMapAgentModel) model;
-		    double[] lastXY = null;
+			MapAgentModel maModel = (MapAgentModel) model;
+		    Point2D lastPt = null;
 		    g2.setColor(Color.red);
 		    for (String loc : maModel.getTourHistory()) {
-		    	double[] xy = maModel.getLocCoords(loc);
-		    	if (xy != null && lastXY != null) {
-		    		g2.drawLine(x(xy), y(xy), x(lastXY), y(lastXY));
+		    	Point2D pt = maModel.getLocCoords(loc);
+		    	if (pt != null && lastPt != null) {
+		    		g2.drawLine(x(pt), y(pt), x(lastPt), y(lastPt));
 		    	}
-		    	lastXY = xy;
+		    	lastPt = pt;
 		    }
 		}
 
@@ -166,11 +167,11 @@ else if (!block.inEnvMap)
 		}
 
 	    private void paintLoc(java.awt.Graphics2D g2, String loc) {
-	    	AbstractMapAgentModel maModel = (AbstractMapAgentModel) model;
-			double[] xy = maModel.getLocCoords(loc);
-	    	if (xy != null) {
-	    		int x = x(xy);
-	    		int y = y(xy);
+	    	MapAgentModel maModel = (MapAgentModel) model;
+			Point2D pt = maModel.getLocCoords(loc);
+	    	if (pt != null) {
+	    		int x = x(pt);
+	    		int y = y(pt);
 		    	String info = "";
 		    	List<String> history = maModel.getTourHistory();
 		    	ArrayList<Integer> list = new ArrayList<Integer>();
@@ -214,11 +215,11 @@ else if (history.contains(loc))
 	 * the road itself so that they always appear in front.
 	 */
 	private static class Roadblock {
-		double[] pos1;
-		double[] pos2;
+		Point2D pos1;
+		Point2D pos2;
 		boolean inEnvMap;
 		boolean inAgentMap;
-		private Roadblock(double[] pos1, double[] pos2, boolean inEnvMap, boolean inAgentMap) {
+		private Roadblock(Point2D pos1, Point2D pos2, boolean inEnvMap, boolean inAgentMap) {
 			this.pos1 = pos1;
 			this.pos2 = pos2;
 			this.inEnvMap = inEnvMap;

src/aima/gui/applications/search/map/MapAgentFrame.java

@@ -4,7 +4,10 @@
 import java.util.List;
 
 import aima.basic.Agent;
+import aima.gui.framework.AgentAppModel;
+import aima.search.map.DynAttributeNames;
 import aima.search.map.Map;
+import aima.search.map.Point2D;
 import aima.search.map.Scenario;
 
 /**
@@ -16,12 +19,46 @@
  * 
  * @author R. Lunde
  */
-public class MapAgentModel extends AbstractMapAgentModel {
+public class MapAgentModel extends AgentAppModel {
 	/** A scenario. */
 	protected Scenario scenario;
 	/** A list of location names, possibly null. */
 	protected List<String> destinations;
 
+	/** Stores the locations, the agent has already visited. */
+	private final ArrayList<String> tourHistory = new ArrayList<String>();
+
+	/** Returns a list of all already visited agent locations. */
+	public List<String> getTourHistory() {
+		return tourHistory;
+	}
+
+	/** Clears the list of already visited locations. */
+	public void clearTourHistory() {
+		tourHistory.clear();
+	}
+
+	/**
+	 * Reacts on environment changes and updates the tour history. The command
+	 * string is always send to all registered model change listeners. If the
+	 * command is a location name (with attached position info) or
+	 * {@link aima.basic.Agent#NO_OP} or {@link aima.basic.Agent#DIE}, the
+	 * agent's current location is added to the tour history and all listeners
+	 * are informed about the change.
+	 */
+	@Override
+	public void envChanged(String command) {
+		for (AgentAppModel.ModelChangedListener listener : listeners)
+			listener.logMessage(command);
+		if (getLocCoords(command) != null || command.equals(Agent.NO_OP)
+				|| command.equals(Agent.DIE)) {
+			String loc = (String) getAgent().getAttribute(
+					DynAttributeNames.AGENT_LOCATION);
+			tourHistory.add(loc);
+			fireModelChanged();
+		}
+	}
+	
 	/**
 	 * Assigns values to the attributes {@link #scenario} and
 	 * {@link #destinations}, clears the history and informs all interested
@@ -40,7 +77,6 @@ public void prepare(Scenario s, List<String> d) {
 	}
 
 	/** Checks whether there is a scenario available. */
-	@Override
 	public boolean isEmpty() {
 		return scenario == null;
 	}
@@ -49,7 +85,6 @@ public boolean isEmpty() {
 	 * Returns all location names mentioned in the environment map or in the
 	 * agent map.
 	 */
-	@Override
 	public List<String> getLocations() {
 		List<String> result = scenario.getEnvMap().getLocations();
 		if (!result.containsAll(scenario.getAgentMap().getLocations())) {
@@ -61,44 +96,51 @@ public List<String> getLocations() {
 		return result;
 	}
 
-	@Override
+	/** Returns the map used by the agent. */
 	public Map getAgentMap() {
 		return scenario.getAgentMap();
 	}
 
-	@Override
+	/** Returns the map used by the environment. */
 	public Map getEnvMap() {
 		return scenario.getEnvMap();
 	}
 
-	@Override
+	/** Returns the agent. */
 	public Agent getAgent() {
 		return (Agent) scenario.getEnv().getAgents().get(0);
 	}
 
-	@Override
+	/** Checks whether a given location is the initial location of the agent. */
 	public boolean isStart(String loc) {
 		return scenario.getInitAgentLocation() == loc;
 	}
 
-	@Override
+	/** Checks whether a given location is one of the specified destinations. */
 	public boolean isDestination(String loc) {
 		return destinations != null && destinations.contains(loc);
 	}
 
-	@Override
-	public double[] getLocCoords(String loc) {
-		return scenario.getEnvMap().getXY(loc);
+	/**
+	 * Returns the coordinates of the specified location.
+	 */
+	public Point2D getLocCoords(String loc) {
+		return scenario.getEnvMap().getPosition(loc);
 	}
 
-	/** Always returns false. */
-	@Override
+	/**
+	 * Checks whether special informations can be perceived at the location.
+	 * This implementation always returns false.
+	 */
+
 	public boolean hasInfos(String loc) {
 		return false; // not implemented yet
 	}
 
-	/** Always returns false. */
-	@Override
+	/**
+	 * Checks whether interesting objects can be perceived at the location.
+	 * This implementation always returns false.
+	 */
 	public boolean hasObjects(String loc) {
 		return false; // not implemented yet
 	}