Moved AmbulatorySprite around and made it implement the Traverser

interface.  Initial version of AStarPathUtil and hooked it in to
SceneView.getPath().  Not yet tested.


git-svn-id: svn+ssh://src.earth.threerings.net/narya/trunk@255 542714f4-19e9-0310-aa3c-eee0fc999fb1

src/java/com/threerings/cast/CharacterSprite.java

@@ -1,16 +1,19 @@
 //
-// $Id: CharacterSprite.java,v 1.4 2001/08/14 23:35:22 mdb Exp $
+// $Id: CharacterSprite.java,v 1.5 2001/08/15 02:30:27 shaper Exp $
 
-package com.threerings.media.sprite;
+package com.threerings.miso.scene;
 
-import com.threerings.media.Log;
+import com.threerings.media.sprite.*;
+import com.threerings.miso.Log;
+import com.threerings.miso.tile.Tile;
+import com.threerings.miso.tile.Traverser;
 
 /**
  * An <code>AmbulatorySprite</code> is a sprite that can face in one of
  * the various compass directions and that can animate itself walking
  * along some chosen path.
  */
-public class AmbulatorySprite extends Sprite
+public class AmbulatorySprite extends Sprite implements Traverser
 {
     /**
      * Construct an <code>AmbulatorySprite</code>, with a multi-frame
@@ -61,6 +64,12 @@ public class AmbulatorySprite extends Sprite
         setAnimationDelay(0);
     }
 
+    public boolean canTraverse (Tile tile)
+    {
+	// by default, passability is solely the province of the tile
+	return tile.passable;
+    }
+
     /** The animation frames for the sprite facing each direction. */
     protected MultiFrameImage[] _anims;
 

src/java/com/threerings/media/tile/Tile.java

@@ -1,5 +1,5 @@
 //
-// $Id: Tile.java,v 1.9 2001/08/13 19:54:39 shaper Exp $
+// $Id: Tile.java,v 1.10 2001/08/15 02:30:27 shaper Exp $
 
 package com.threerings.miso.tile;
 
@@ -30,10 +30,10 @@ public class Tile
 
     /**
      * Construct a new tile with the specified identifiers.  Intended
-     * only for use by the <code>TileManager</code>.  Do not call this
+     * only for use by the <code>TileSet</code>.  Do not call this
      * method.
      *
-     * @see TileManager#getTile
+     * @see TileSet#getTile
      */
     public Tile (int tsid, int tid)
     {

src/java/com/threerings/miso/client/IsoSceneView.java

@@ -1,5 +1,5 @@
 //
-// $Id: IsoSceneView.java,v 1.44 2001/08/15 01:08:49 mdb Exp $
+// $Id: IsoSceneView.java,v 1.45 2001/08/15 02:30:27 shaper Exp $
 
 package com.threerings.miso.scene;
 
@@ -15,6 +15,7 @@ import com.threerings.media.sprite.*;
 import com.threerings.miso.Log;
 import com.threerings.miso.tile.Tile;
 import com.threerings.miso.tile.TileManager;
+import com.threerings.miso.scene.util.AStarPathUtil;
 import com.threerings.miso.scene.util.IsoUtil;
 
 /**
@@ -539,7 +540,7 @@ public class IsoSceneView implements EditableSceneView
         _model.precalculate();
     }
 
-    public Path getPath (Sprite sprite, int x, int y)
+    public Path getPath (AmbulatorySprite sprite, int x, int y)
     {
         // make sure the destination point is within our bounds
         if (x < 0 || x >= _model.bounds.width ||
@@ -550,13 +551,43 @@ public class IsoSceneView implements EditableSceneView
 	// constrain destination pixels to fine coordinates
 	Point fpos = new Point();
 	IsoUtil.screenToFull(_model, x, y, fpos);
-	Point spos = new Point();
+//  	Point spos = new Point();
-	IsoUtil.fullToScreen(_model, fpos.x, fpos.y, spos);
+//  	IsoUtil.fullToScreen(_model, fpos.x, fpos.y, spos);
 
-	// create path from current loc to destination
+	// calculate tile coordinates for start and end position
+	Point stpos = new Point();
+	IsoUtil.screenToTile(_model, sprite.x, sprite.y, stpos);
+	int tbx = IsoUtil.fullToTile(fpos.x);
+	int tby = IsoUtil.fullToTile(fpos.y);
+
+	// get a reasonable path from start to end
+	List tilepath =
+	    AStarPathUtil.getPath(
+		_scene.tiles, MisoScene.TILE_WIDTH, MisoScene.TILE_HEIGHT,
+		sprite, stpos.x, stpos.y, tbx, tby);
+
+	// construct the path object and starting node
         Path path = new Path(sprite.x, sprite.y);
-	int dir = IsoUtil.getDirection(_model, sprite.x, sprite.y, x, y);
+
-        path.addNode(spos.x, spos.y, dir);
+	// add all nodes on the calculated path
+	Point nspos = new Point();
+	int size = tilepath.size();
+	Point prev = stpos;
+	for (int ii = 0; ii < size; ii++) {
+	    Point n = (Point)tilepath.get(ii);
+
+	    // determine the direction this node lies in from the
+	    // previous node
+	    int dir = IsoUtil.getIsoDirection(prev.x, prev.y, n.x, n.y);
+
+	    // determine the node's position in screen pixel coordinates 
+	    IsoUtil.tileToScreen(_model, n.x, n.y, nspos);
+
+	    // add the node to the path
+	    path.addNode(nspos.x, nspos.y, dir);
+
+	    prev = n;
+	}
 
         return path;
     }

src/java/com/threerings/miso/client/SceneView.java

@@ -1,5 +1,5 @@
 //
-// $Id: SceneView.java,v 1.11 2001/08/15 01:08:49 mdb Exp $
+// $Id: SceneView.java,v 1.12 2001/08/15 02:30:27 shaper Exp $
 
 package com.threerings.miso.scene;
 
@@ -41,5 +41,5 @@ public interface SceneView extends AnimatedView
      *
      * @return the sprite's path or null if no valid path exists.
      */
-    public Path getPath (Sprite sprite, int x, int y);
+    public Path getPath (AmbulatorySprite sprite, int x, int y);
 }

src/java/com/threerings/miso/client/Traverser.java

@@ -0,0 +1,23 @@
+//
+// $Id: Traverser.java,v 1.1 2001/08/15 02:30:27 shaper Exp $
+
+package com.threerings.miso.tile;
+
+/**
+ * The <code>Traverser</code> interface should be implemented by
+ * sprites that are going to traverse some path in a scene.  This
+ * allows path determination to take into account any special
+ * abilities the traverser may have that alter the traversability of
+ * tiles.
+ */
+public interface Traverser
+{
+    /**
+     * Return whether the traverser can traverse the specified tile.
+     *
+     * @param tile the tile to traverse.
+     *
+     * @return whether the tile is traversable.
+     */
+    public boolean canTraverse (Tile tile);
+}

src/java/com/threerings/miso/client/util/AStarPathUtil.java

@@ -0,0 +1,277 @@
+//
+// $Id: AStarPathUtil.java,v 1.1 2001/08/15 02:30:27 shaper Exp $
+
+package com.threerings.miso.scene.util;
+
+import java.awt.Point;
+import java.util.*;
+
+import com.threerings.miso.Log;
+import com.threerings.miso.tile.Tile;
+import com.threerings.miso.tile.Traverser;
+import com.threerings.media.util.MathUtil;
+
+/**
+ * The <code>AStarPathUtil</code> class provides a facility for
+ * finding a reasonable path between two points in a scene using the
+ * A* search algorithm.
+ *
+ * <p> See the path-finding article on
+ * <a href="http://www.gamasutra.com/features/19990212/sm_01.htm">
+ * Gamasutra</a> for more detailed information.
+ */
+public class AStarPathUtil
+{
+    /**
+     * Return a list of <code>Point</code> objects representing a path
+     * from coordinates <code>(ax, by)</code> to
+     * <code>(bx, by)</code>, inclusive, determined by performing an
+     * A* search in the given array of tiles.  Assumes the starting
+     * and destination nodes are traversable by the specified
+     * traverser.
+     *
+     * @param tiles the tile array.
+     * @param tilewid the tile array width.
+     * @param tilehei the tile array height.
+     * @param trav the traverser to follow the path.
+     * @param ax the starting x-position in tile coordinates.
+     * @param ay the starting y-position in tile coordinates.
+     * @param bx the ending x-position in tile coordinates.
+     * @param by the ending y-position in tile coordinates.
+     *
+     * @return the list of points in the path.
+     */
+    public static List getPath (
+	Tile tiles[][][], int tilewid, int tilehei, Traverser trav,
+	int ax, int ay, int bx, int by)
+    {
+	AStarInfo info = new AStarInfo(tiles, tilewid, tilehei, trav, bx, by);
+
+	// set up the starting node
+	AStarNode s = getNode(info, ax, ay);
+	s.g = 0;
+	s.h = getDistanceEstimate(ax, ay, bx, by);
+	s.f = s.g + s.h;
+
+	// push starting node on the open list
+	info.open.add(s);
+
+	// while there are more nodes on the open list
+	while (info.open.size() > 0) {
+
+	    // pop the best node so far from open
+	    AStarNode n = (AStarNode)info.open.first();
+	    info.open.remove(n);
+
+	    // if node is a goal node
+	    if (n.x == bx && n.y == by) {
+		// construct and return the acceptable path
+		return getNodePath(n);
+	    }
+
+	    // TODO: don't allow diagonal traversal if horiz and vert
+	    // are impassable.
+
+	    // consider each successor of the node
+	    considerStep(info, n, n.x - 1, n.y - 1);
+	    considerStep(info, n, n.x, n.y - 1);
+	    considerStep(info, n, n.x + 1, n.y - 1);
+	    considerStep(info, n, n.x - 1, n.y);
+	    considerStep(info, n, n.x + 1, n.y);
+	    considerStep(info, n, n.x - 1, n.y + 1);
+	    considerStep(info, n, n.x, n.y + 1);
+	    considerStep(info, n, n.x + 1, n.y + 1);
+
+	    // push the node on the closed list
+	    info.closed.add(n);
+	}
+
+	// no path found
+	return null;
+    }
+
+    /**
+     * Consider the step <code>(n.x, n.y)</code> to <code>(x, y)</code>
+     * for possible inclusion in the path.
+     *
+     * @param info the info object.
+     * @param n the originating node for the step.
+     * @param x the x-coordinate for the destination step.
+     * @param y the y-coordinate for the destination step.
+     */
+    protected static void considerStep (
+	AStarInfo info, AStarNode n, int x, int y)
+    {
+	// skip node if it's outside the map bounds
+	if (x < 0 || y < 0 || x >= info.tilewid || y >= info.tilehei) {
+	    return;
+	}
+
+	// skip node if it's impassable
+	// TODO: fix hard-coded consideration of only the base layer
+	if (!info.trav.canTraverse(info.tiles[x][y][0])) return;
+
+	// calculate the new cost for this node
+	int newg = n.g + 1; // getCost() is always 1?
+
+	// retrieve the node corresponding to this location
+	AStarNode np = getNode(info, x, y);
+
+	// skip if it's already in the open or closed list or if its
+	// actual cost is less than the just-calculated cost
+	// TODO: shouldn't <= below be >=?
+	if ((info.open.contains(np) || info.closed.contains(np)) &&
+	    np.g <= newg) {
+	    return;
+	}
+
+	// update the node's information
+	np.parent = n;
+	np.g = newg;
+	np.h = getDistanceEstimate(np.x, np.y, info.destx, info.desty);
+	np.f = np.g + np.h;
+
+	// remove it from the closed list if it's present
+	info.closed.remove(np);
+
+	// add it to the open list in case it's not already there
+	info.open.add(np);
+    }
+
+    /**
+     * Return a list of <code>Point</code> objects detailing the path
+     * from the first node (the given node's ultimate parent) to the
+     * ending node (the given node itself.)
+     *
+     * @param n the ending node in the path.
+     *
+     * @return the list detailing the path.
+     */
+    protected static List getNodePath (AStarNode n)
+    {
+	AStarNode cur = n;
+	ArrayList path = new ArrayList();
+
+	while (cur != null) {
+	    // add to the head of the list since we're traversing from
+	    // the end to the beginning
+	    path.add(0, new Point(cur.x, cur.y));
+
+	    // advance to the next node in the path
+	    cur = cur.parent;
+	}
+
+	return path;
+    }
+
+    /**
+     * Return the <code>AStarNode</code> object corresponding to the
+     * specified tile coordinate.  Creates the node and saves it in
+     * the node array if this is its first reference.
+     */
+    protected static AStarNode getNode (AStarInfo info, int x, int y)
+    {
+	AStarNode n = info.nodes[x][y];
+	return (n == null) ? (info.nodes[x][y] = new AStarNode(x, y)) : n;
+    }
+
+    /**
+     * Return a heuristic estimate of the cost to get from
+     * <code>(ax, ay)</code> to <code>(bx, by)</code>.
+     */
+    protected static int getDistanceEstimate (int ax, int ay, int bx, int by)
+    {
+	return (int)MathUtil.distance(ax, ay, bx, by);
+    }
+}
+
+/**
+ * A holding class to contain the wealth of information referenced
+ * while performing an A* search for a path through a tile array.
+ */
+class AStarInfo
+{
+    /** The array of tiles being traversed. */
+    public Tile tiles[][][];
+
+    /** The tile array dimensions. */
+    public int tilewid, tilehei;
+
+    /** The traverser moving along the path. */
+    public Traverser trav;
+
+    /** The array of A*-specific node info to match the tile array. */
+    public AStarNode nodes[][];
+
+    /** The set of open nodes being searched. */
+    public SortedSet open;
+
+    /** The set of closed nodes being searched. */
+    public ArrayList closed;
+
+    /** The destination coordinates in the tile array. */
+    public int destx, desty;
+
+    public AStarInfo (
+	Tile tiles[][][], int tilewid, int tilehei, Traverser trav,
+	int destx, int desty)
+    {
+	// save off references
+	this.tiles = tiles;
+	this.tilewid = tilewid;
+	this.tilehei = tilehei;
+	this.trav = trav;
+	this.destx = destx;
+	this.desty = desty;
+
+	// construct the node array
+	nodes = new AStarNode[tilewid][tilehei];
+
+	// construct the open and closed lists
+	open = new TreeSet();
+	closed = new ArrayList();
+    }
+}
+
+/**
+ * A class that represents a single traversable node in the tile array
+ * along with its current A*-specific search information.
+ */
+class AStarNode implements Comparable
+{
+    /** The node coordinates. */
+    public int x, y;
+
+    /** The actual cheapest cost of arriving here from the start. */
+    public int g;
+
+    /** The heuristic estimate of the cost to the goal from here. */
+    public int h;
+
+    /** The score assigned to this node. */
+    public int f;
+
+    /** The node from which we reached this node. */
+    public AStarNode parent;
+
+    public AStarNode (int x, int y)
+    {
+	this.x = x;
+	this.y = y;
+    }
+
+    public int compareTo (Object o)
+    {
+	int bf = ((AStarNode)o).f;
+
+	if (f == bf){
+	    return 0;
+	}
+
+	if (f < bf)  {
+	    return -1;
+	}
+
+	return 1;
+    }
+}

src/java/com/threerings/miso/client/util/IsoUtil.java

@@ -1,5 +1,5 @@
 //
-// $Id: IsoUtil.java,v 1.2 2001/08/14 23:35:22 mdb Exp $
+// $Id: IsoUtil.java,v 1.3 2001/08/15 02:30:27 shaper Exp $
 
 package com.threerings.miso.scene.util;
 
@@ -48,7 +48,7 @@ public class IsoUtil
 	int tby = bfpos.y / FULL_TILE_FACTOR;
 
 	// compare tile coordinates to determine direction
-	int dir = getIsoDirection(model, tax, tay, tbx, tby);
+	int dir = getIsoDirection(tax, tay, tbx, tby);
 	if (dir != Path.DIR_NONE) return dir;
 
 	// destination point is in the same tile as the
@@ -62,7 +62,7 @@ public class IsoUtil
 	int fby = bfpos.y - (tby * FULL_TILE_FACTOR);
 
 	// compare fine coordinates to determine direction
-	dir = getIsoDirection(model, fax, fay, fbx, fby);
+	dir = getIsoDirection(fax, fay, fbx, fby);
 
 	// arbitrarily return southwest if fine coords were also equivalent
 	return (dir == -1) ? Path.DIR_SOUTHWEST : dir;
@@ -84,8 +84,7 @@ public class IsoUtil
      *         class's direction constants, or <code>Path.DIR_NONE</code> 
      *         if point B is equivalent to point A.
      */
-    public static int getIsoDirection (
+    public static int getIsoDirection (int ax, int ay, int bx, int by)
-	IsoSceneModel model, int ax, int ay, int bx, int by)
     {
 	if (bx > ax) {
 	    if (by == ay) return Path.DIR_SOUTH;
@@ -101,6 +100,16 @@ public class IsoUtil
 	}
     }
 
+    public static int fullToTile (int val)
+    {
+	return (val / FULL_TILE_FACTOR);
+    }
+
+    public static int fullToFine (int val)
+    {
+	return (val - ((val / FULL_TILE_FACTOR) * FULL_TILE_FACTOR));
+    }
+
     /**
      * Convert the given screen-based pixel coordinates to their
      * corresponding tile-based coordinates.  Converted coordinates

src/java/com/threerings/miso/client/util/PathUtil.java

@@ -1,35 +0,0 @@
-//
-// $Id: PathUtil.java,v 1.1 2001/08/14 21:29:40 shaper Exp $
-
-package com.threerings.miso.scene.util;
-
-import java.util.ArrayList;
-
-import com.threerings.miso.Log;
-import com.threerings.miso.tile.Tile;
-
-/**
- * The <code>PathUtil</code> class provides utility routines for
- * finding a reasonable path between two points in a scene.
- */
-public class PathUtil
-{
-    /**
-     * Return a list of <code>Point</code> objects representing a path
-     * from coordinates (ax, by) to (bx, by), inclusive, determined by
-     * performing an A* search in the given array of tiles.
-     *
-     * @param tiles the tile array.
-     * @param ax the starting x-position in tile coordinates.
-     * @param ay the starting y-position in tile coordinates.
-     * @param bx the ending x-position in tile coordinates.
-     * @param by the ending y-position in tile coordinates.
-     *
-     * @return the list of points in the path.
-     */
-    public static ArrayList getAStarPath (
-	Tile tiles[][], int ax, int ay, int bx, int by)
-    {
-	return null;
-    }
-}

src/java/com/threerings/miso/tile/TileUtil.java

@@ -1,13 +1,13 @@
 //
-// $Id: TileUtil.java,v 1.1 2001/08/14 23:35:22 mdb Exp $
+// $Id: TileUtil.java,v 1.2 2001/08/15 02:30:27 shaper Exp $
 
 package com.threerings.miso.tile;
 
 import java.awt.Image;
 
-import com.threerings.media.sprite.AmbulatorySprite;
 import com.threerings.media.sprite.MultiFrameImage;
 import com.threerings.media.sprite.Path;
+import com.threerings.miso.scene.AmbulatorySprite;
 
 /**
  * Tile-related utility functions.

tests/src/java/com/threerings/miso/viewer/ViewerFrame.java

@@ -1,5 +1,5 @@
 //
-// $Id: ViewerFrame.java,v 1.11 2001/08/15 01:08:49 mdb Exp $
+// $Id: ViewerFrame.java,v 1.12 2001/08/15 02:30:28 shaper Exp $
 
 package com.threerings.miso.viewer;
 
@@ -13,6 +13,7 @@ import com.samskivert.swing.*;
 import com.threerings.media.sprite.*;
 
 import com.threerings.miso.Log;
+import com.threerings.miso.scene.AmbulatorySprite;
 import com.threerings.miso.tile.TileManager;
 import com.threerings.miso.tile.TileUtil;
 import com.threerings.miso.viewer.util.ViewerContext;

tests/src/java/com/threerings/miso/viewer/ViewerSceneViewPanel.java

@@ -1,5 +1,5 @@
 //
-// $Id: ViewerSceneViewPanel.java,v 1.9 2001/08/15 00:10:58 mdb Exp $
+// $Id: ViewerSceneViewPanel.java,v 1.10 2001/08/15 02:30:28 shaper Exp $
 
 package com.threerings.miso.viewer;
 
@@ -24,7 +24,7 @@ public class ViewerSceneViewPanel extends SceneViewPanel
      * Construct the panel and initialize it with a context.
      */
     public ViewerSceneViewPanel (
-	ViewerContext ctx, SpriteManager spritemgr, Sprite sprite)
+	ViewerContext ctx, SpriteManager spritemgr, AmbulatorySprite sprite)
     {
 	super(ctx.getTileManager(), spritemgr);
 
@@ -120,7 +120,7 @@ public class ViewerSceneViewPanel extends SceneViewPanel
     AnimationManager _animmgr;
 
     /** The sprite we're manipulating within the view. */
-    protected Sprite _sprite;
+    protected AmbulatorySprite _sprite;
 
     /** The context object. */
     protected ViewerContext _ctx;