Thomas Foote
8 years ago
25 changed files with 587 additions and 195 deletions
@ -1,7 +1,8 @@ |
|||
package com.droidquest.materials; |
|||
package com.droidquest.materials.switches; |
|||
|
|||
import com.droidquest.Room; |
|||
import com.droidquest.items.Item; |
|||
import com.droidquest.materials.Material; |
|||
|
|||
import javax.swing.*; |
|||
import java.awt.*; |
|||
@ -1,7 +1,7 @@ |
|||
package com.droidquest.items; |
|||
package com.droidquest.materials.switches; |
|||
|
|||
import com.droidquest.Room; |
|||
import com.droidquest.materials.Switch; |
|||
import com.droidquest.items.Item; |
|||
|
|||
public class Switch4A extends Switch { |
|||
int count = 0; |
|||
@ -0,0 +1,180 @@ |
|||
package com.droidquest.pathfinder; |
|||
|
|||
import com.droidquest.materials.Material; |
|||
|
|||
/** |
|||
* Represents a Node in a path, using the A* algorithm. |
|||
*/ |
|||
public class Node implements Cloneable { |
|||
private int x = -1; |
|||
private int y = -1; |
|||
private Material material = null; |
|||
|
|||
private int gCost = 0; |
|||
private int hCost = 0; |
|||
private int fCost = 0; |
|||
|
|||
Node parent = null; |
|||
|
|||
/** |
|||
* Create a new, empty Node |
|||
*/ |
|||
public Node() { |
|||
this(-1, -1, null, null); |
|||
} |
|||
|
|||
/** |
|||
* Create a new Node with given coordinates |
|||
* @param x Coordinate (of the room array, not screen location) |
|||
* @param y Coordinate (of the room array, not screen location) |
|||
*/ |
|||
public Node(int x, int y) { |
|||
this(x, y, null, null); |
|||
} |
|||
|
|||
/** |
|||
* Create a new room Node with the given coordinates and material |
|||
* @param x Coordinate (of the room array, not screen location) |
|||
* @param y Coordinate (of the room array, not screen location) |
|||
* @param mat Material at the Node location |
|||
*/ |
|||
public Node(int x, int y, Material mat) { |
|||
this(x, y, null, mat); |
|||
} |
|||
|
|||
/** |
|||
* Create a new room Node with a given parent Node (for pathing) |
|||
* @param x Coordinate (of the room array, not screen location) |
|||
* @param y Coordinate (of the room array, not screen location) |
|||
* @param parent current Parent node |
|||
*/ |
|||
public Node(int x, int y, Node parent) { |
|||
this(x, y, parent, null); |
|||
} |
|||
|
|||
/** |
|||
* Create a new room node with a given parent Node and Material |
|||
* @param x Coordinate (of the room array, not screen location) |
|||
* @param y Coordinate (of the room array, not screen location) |
|||
* @param parent current Parent node |
|||
* @param mat Material at the Node location |
|||
*/ |
|||
public Node(int x, int y, Node parent, Material mat) { |
|||
this.x = x; |
|||
this.y = y; |
|||
this.parent = parent; |
|||
this.material = mat; |
|||
} |
|||
|
|||
/** |
|||
* Retrieve the current room location X coordinate (room array, not screen location) |
|||
* @return X coordinate |
|||
*/ |
|||
public int getX() { |
|||
return x; |
|||
} |
|||
|
|||
/** |
|||
* Set the current room location X coordinate (room array, not screen location) |
|||
* @param x coordinate |
|||
*/ |
|||
public void setX(int x) { |
|||
this.x = x; |
|||
} |
|||
|
|||
/** |
|||
* Retrieve the current room location Y coordinate (room array, not screen location) |
|||
* @return y coordinate |
|||
*/ |
|||
public int getY() { |
|||
return y; |
|||
} |
|||
|
|||
/** |
|||
* Set the current room Y coordinate (room array, not screen location) |
|||
* @param y coordinate |
|||
*/ |
|||
public void setY(int y) { |
|||
this.y = y; |
|||
} |
|||
|
|||
/** |
|||
* Retrieve the currently set Material for the Node (or null if not set) |
|||
* @return Material |
|||
* @see com.droidquest.materials.Material |
|||
*/ |
|||
public Material getMaterial() { |
|||
return material; |
|||
} |
|||
|
|||
/** |
|||
* Set the Material for the Node |
|||
* @param material Material |
|||
* @see com.droidquest.materials.Material |
|||
*/ |
|||
public void setMaterial(Material material) { |
|||
this.material = material; |
|||
} |
|||
|
|||
/** |
|||
* Create a clone of this Node |
|||
* @return Node clone (as Object) |
|||
*/ |
|||
public Object clone() { |
|||
try { |
|||
return super.clone(); |
|||
} |
|||
catch(CloneNotSupportedException cnse) { |
|||
System.out.println("Clone not supported!"); |
|||
return this; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Set the gCost (cost to the current Node from the origin) |
|||
* @return int cost |
|||
*/ |
|||
public int getgCost() { |
|||
return gCost; |
|||
} |
|||
|
|||
/** |
|||
* Set the gCost (cost to the current Node from the origin) |
|||
* @param gCost int cost |
|||
*/ |
|||
public void setgCost(int gCost) { |
|||
this.gCost = gCost; |
|||
} |
|||
|
|||
/** |
|||
* Retrieves the hCost (heuristic cost) from the current Node to the end Node |
|||
* @return int cost |
|||
*/ |
|||
public int gethCost() { |
|||
return hCost; |
|||
} |
|||
|
|||
/** |
|||
* Sets the hCost (heuristic cost) from the current Node to the end Node |
|||
* @param hCost int cost |
|||
*/ |
|||
public void sethCost(int hCost) { |
|||
this.hCost = hCost; |
|||
} |
|||
|
|||
/** |
|||
* Retrieves the fCost (full cost) for the Node |
|||
* @return int cost |
|||
*/ |
|||
public int getfCost() { |
|||
return fCost; |
|||
} |
|||
|
|||
/** |
|||
* Sets the fCost (full cost) for the Node |
|||
* @param fCost int cost |
|||
*/ |
|||
public void setfCost(int fCost) { |
|||
this.fCost = fCost; |
|||
} |
|||
} |
|||
@ -0,0 +1,178 @@ |
|||
package com.droidquest.pathfinder; |
|||
|
|||
import com.droidquest.Room; |
|||
import com.droidquest.items.Item; |
|||
|
|||
import java.util.ArrayList; |
|||
import java.util.Collections; |
|||
|
|||
/** |
|||
* Finds a path between two places on the map, using the A* algorithm |
|||
*/ |
|||
public class Pathfinder { |
|||
private ArrayList<ArrayList<Node>> nodeList = new ArrayList<ArrayList<Node>>(); |
|||
|
|||
private ArrayList<Node> openList = new ArrayList<Node>(); |
|||
|
|||
private ArrayList<Node> closedList = new ArrayList<Node>(); |
|||
|
|||
/** |
|||
* Begin a search for a path. Returns an empty ArrayList if no path found. |
|||
* @param startX int starting X coordinate (not screen location) |
|||
* @param startY int starting Y coordinate (not screen location) |
|||
* @param endX int ending X coordinate (not screen location) |
|||
* @param endY int ending Y coordinate (not screen location) |
|||
* @param player Item player used to verify whether a Node is passable. |
|||
* @return ArrayList of Nodes representing the path, or empty list |
|||
*/ |
|||
public ArrayList<Node> search(int startX, int startY, int endX, int endY, Item player) { |
|||
ArrayList<Node> results = new ArrayList<Node>(); |
|||
if(startY < 0 || startY > nodeList.size() || startX < 0 || startX > nodeList.get(startY).size()) { |
|||
System.out.println("Starting node outside of room bounds!"); |
|||
return results; |
|||
} |
|||
|
|||
if(endY < 0 || endY > nodeList.size() || endX < 0 || endX > nodeList.get(endY).size()) { |
|||
System.out.println("Ending node outside of room bounds!"); |
|||
return results; |
|||
} |
|||
|
|||
if(!nodeList.get(startY).get(startX).getMaterial().Passable(player)) { |
|||
System.out.println("Starting node isn't passable!"); |
|||
return results; |
|||
} |
|||
|
|||
if(!nodeList.get(endY).get(endX).getMaterial().Passable(player)) { |
|||
System.out.println("Ending node isn't passable!"); |
|||
return results; |
|||
} |
|||
|
|||
Node endNode = nodeList.get(endY).get(endX); |
|||
|
|||
// Add nodes adjacent to starting node
|
|||
Node startNode = nodeList.get(startY).get(startX); |
|||
startNode.setgCost(0); |
|||
startNode.sethCost(manhattanDistance(startNode, endNode)); |
|||
startNode.setfCost(startNode.gethCost()); |
|||
startNode.parent = null; |
|||
openList.add(startNode); |
|||
|
|||
findLowestCost(results, endNode, player); |
|||
|
|||
return results; |
|||
} |
|||
|
|||
private void findLowestCost(ArrayList<Node> results, Node endNode, Item player) { |
|||
|
|||
while(openList.size() > 0) { |
|||
Node lowestCost = null; |
|||
for (Node node : openList) { |
|||
if (lowestCost == null || node.getfCost() < lowestCost.getfCost()) { |
|||
lowestCost = node; |
|||
} |
|||
} |
|||
|
|||
openList.remove(lowestCost); |
|||
closedList.add(lowestCost); |
|||
|
|||
if (lowestCost != null && lowestCost == endNode) { |
|||
Node pathNode = lowestCost; |
|||
while (pathNode.parent != null) { |
|||
results.add(new Node(pathNode.getX() * 28, pathNode.getY() * 32)); |
|||
pathNode = pathNode.parent; |
|||
} |
|||
Collections.reverse(results); |
|||
return; |
|||
|
|||
} |
|||
|
|||
addSurroundingNodes(lowestCost, endNode, player); |
|||
} |
|||
|
|||
System.out.println("Could not find any nodes to process, no path."); |
|||
|
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
private void addSurroundingNodes(Node parent, Node endNode, Item player) { |
|||
if(parent == null) { |
|||
return; |
|||
} |
|||
|
|||
int x = parent.getX(); |
|||
int y = parent.getY(); |
|||
for(int deltaY = -1; deltaY <= 1; deltaY++) { |
|||
for(int deltaX = -1; deltaX <=1; deltaX++) { |
|||
if(deltaX != 0 || deltaY != 0) { |
|||
int checkX = x + deltaX; |
|||
int checkY = y + deltaY; |
|||
if(checkY >= 0 && checkY < nodeList.size() && checkX >= 0 && checkX < nodeList.get(checkY).size() && nodeList.get(checkY).get(checkX).getMaterial().Passable(player)) { |
|||
Node currentNode = nodeList.get(checkY).get(checkX); |
|||
if(closedList.contains(currentNode)) { |
|||
continue; |
|||
} |
|||
int diagonalCost = 0; |
|||
if(deltaX != 0 && deltaY != 0) { |
|||
|
|||
// Diagonal, check to make sure other squares are passable
|
|||
if(!nodeList.get(y).get(checkX).getMaterial().Passable(player) || !nodeList.get(checkY).get(x).getMaterial().Passable(player)) { |
|||
diagonalCost = 500; // don't make impassible, just really expensive
|
|||
} |
|||
} |
|||
if(openList.contains(currentNode)) { |
|||
// Set gCost (10 for orthoginal, 14 for diagonal)
|
|||
int newgCost = parent.getgCost() + ((deltaX == 0 || deltaY == 0) ? 10 : 14) + diagonalCost; |
|||
if(newgCost < currentNode.getgCost()) { |
|||
currentNode.parent = parent; |
|||
currentNode.setgCost(newgCost); |
|||
currentNode.setfCost(newgCost + manhattanDistance(currentNode, endNode)); |
|||
} |
|||
} |
|||
else { |
|||
openList.add(currentNode); |
|||
currentNode.parent = parent; |
|||
|
|||
// Set gCost (10 for orthoginal, 14 for diagonal)
|
|||
currentNode.setgCost(parent.getgCost() + ((deltaX == 0 || deltaY == 0) ? 10 : 14) + diagonalCost); |
|||
currentNode.sethCost(manhattanDistance(currentNode, endNode)); |
|||
currentNode.setfCost(currentNode.getgCost() + currentNode.gethCost()); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
} |
|||
|
|||
/** |
|||
* Create a new Pathfinder object and initialize with a Room |
|||
* @param room Room for path-finding. |
|||
* @see com.droidquest.Room |
|||
*/ |
|||
public Pathfinder(Room room) { |
|||
// Generate node array for room
|
|||
generate(room); |
|||
|
|||
} |
|||
|
|||
/** |
|||
* Generate the Node list for a Room. Generally should use new Pathfinder(room) instead of this method |
|||
* @param room Room for path-finding |
|||
*/ |
|||
public void generate(Room room) { |
|||
for(int y = 0; y < room.RoomArray.length;y++) { |
|||
nodeList.add(new ArrayList<Node>()); |
|||
for(int x=0;x<room.RoomArray[y].length;x++) { |
|||
nodeList.get(y).add(new Node(x, y, Room.level.materialAt(x, y, room))); |
|||
} |
|||
} |
|||
} |
|||
|
|||
// Use the Manhattan distance as the heuristic
|
|||
private int manhattanDistance(Node current, Node end) { |
|||
return 10 * Math.abs(end.getX()-current.getX()) + Math.abs(end.getY()-current.getY()); |
|||
} |
|||
|
|||
} |
|||
Loading…
Reference in new issue