ziver/evil-inside
1
0
Fork 0
Code Pull requests Releases Activity

Browse source
This commit is contained in:
Ziver Koc 2007-04-16 19:18:17 +00:00
parent a7749878f0
commit acde8264af
2 changed files with 0 additions and 234 deletions
Download patch file Download diff file Expand all files Collapse all files

111
src/ei/game/algo/AStar.java
View file

@ -1,111 +0,0 @@
package ei.game.algo;
import java.util.*;
/**
The AStarSearch class, along with the AStarNode class,
implements a generic A* search algorithm. The AStarNode
class should be subclassed to provide searching capability.
*/
public class AStar {
/**
A simple priority list, also called a priority queue.
Objects in the list are ordered by their priority,
determined by the object's Comparable interface.
The highest priority item is first in the list.
*/
public static class PriorityList extends LinkedList {
private static final long serialVersionUID = 1L;
public void add(Comparable object) {
for (int i=0; i<size(); i++) {
if (object.compareTo(get(i)) <= 0) {
add(i, object);
return;
}
}
addLast(object);
}
}
/**
Construct the path, not including the start node.
*/
protected List constructPath(AStarNode node) {
LinkedList<AStarNode> path = new LinkedList<AStarNode>();
while (node.pathParent != null) {
path.addFirst(node);
node = node.pathParent;
}
return path;
}
private boolean contains(LinkedList<AStarNode> list,AStarNode find){
for(int i=0; i<list.size() ;i++){
if(list.get(i).getPos().getX() == find.getPos().getX() &&
list.get(i).getPos().getY() == find.getPos().getY())
return true;
}
return false;
}
/**
Find the path from the start node to the end node. A list
of AStarNodes is returned, or null if the path is not
found.
*/
public List findPath(AStarNode startNode, AStarNode goalNode) {
PriorityList openList = new PriorityList();
LinkedList<AStarNode> closedList = new LinkedList<AStarNode>();
startNode.costFromStart = 0;
startNode.estimatedCostToGoal =
startNode.getEstimatedCost(goalNode);
startNode.pathParent = null;
openList.add(startNode);
while (!openList.isEmpty()) {
AStarNode node = (AStarNode)openList.removeFirst();
if (node == goalNode) {
// construct the path from start to goal
return constructPath(goalNode);
}
List neighbors = node.getNeighbors();
for (int i=0; i<neighbors.size(); i++) {
AStarNode neighborNode =
(AStarNode)neighbors.get(i);
boolean isOpen = contains(openList,neighborNode);
boolean isClosed = contains(closedList,neighborNode);
float costFromStart = node.costFromStart +
node.getCost(neighborNode);
// check if the neighbor node has not been
// traversed or if a shorter path to this
// neighbor node is found.
if ((!isOpen && !isClosed) ||
costFromStart < neighborNode.costFromStart)
{
neighborNode.pathParent = node;
neighborNode.costFromStart = costFromStart;
neighborNode.estimatedCostToGoal =
neighborNode.getEstimatedCost(goalNode);
if (isClosed) {
closedList.remove(neighborNode);
}
if (!isOpen) {
openList.add(neighborNode);
}
}
}
closedList.add(node);
}
// no path found
return null;
}
}

123
src/ei/game/algo/AStarNode.java
View file

@ -1,123 +0,0 @@
package ei.game.algo;
import java.util.LinkedList;
import java.util.List;
import ei.engine.math.Vector2i;
import ei.game.gamestate.InGameState;
/**
The AStarNode class, along with the AStarSearch class,
implements a generic A* search algorithm. The AStarNode
class should be subclassed to provide searching capability.
*/
public class AStarNode implements Comparable {
private Vector2i pos;
AStarNode pathParent;
float costFromStart;
float estimatedCostToGoal;
public AStarNode(Vector2i pos,AStarNode parent){
this.pos = pos;
this.pathParent = parent;
}
public float getCost() {
return costFromStart + estimatedCostToGoal;
}
public int compareTo(Object other) {
float thisValue = this.getCost();
float otherValue = ((AStarNode)other).getCost();
float v = thisValue - otherValue;
return (v>0)?1:(v<0)?-1:0; // sign function
}
public Vector2i getPos(){
return pos;
}
/**
Gets the cost between this node and the specified
adjacent (AKA "neighbor" or "child") node.
*/
public float getCost(AStarNode node){
if(pos.getX() != node.getPos().getX() &&
pos.getY() != node.getPos().getY()){
return 14;
}
return 10;
}
/**
Gets the estimated cost between this node and the
specified node. The estimated cost should never exceed
the true cost. The better the estimate, the more
effecient the search.
*/
public float getEstimatedCost(AStarNode node) {
int sum = 0;
if(pos.getX() > node.getPos().getX())
sum += pos.getX()-node.getPos().getX();
else
sum += node.getPos().getX()-pos.getX();
if(pos.getY() > node.getPos().getY())
sum += pos.getY()-node.getPos().getY();
else
sum += node.getPos().getY()-pos.getY();
return sum;
}
/**
Gets the children (AKA "neighbors" or "adjacent nodes")
of this node.
*/
public List getNeighbors() {
LinkedList<AStarNode> list = new LinkedList<AStarNode>();
Vector2i tempV;
//********Vertical and Horisontle
tempV = new Vector2i(pos.getX()+1,pos.getY());
if(tempV.getX() < InGameState.getMap().getSize().getX() && InGameState.getMap().isPosEmpty(tempV.getX(), tempV.getY()))
list.add(new AStarNode(tempV,this));
tempV = new Vector2i(pos.getX()-1,pos.getY());
if(tempV.getX() >= 0 && InGameState.getMap().isPosEmpty(tempV.getX(), tempV.getY()))
list.add(new AStarNode(tempV,this));
tempV = new Vector2i(pos.getX(),pos.getY()+1);
if(tempV.getY() < InGameState.getMap().getSize().getY() && InGameState.getMap().isPosEmpty(tempV.getX(), tempV.getY()))
list.add(new AStarNode(tempV,this));
tempV = new Vector2i(pos.getX(),pos.getY()-1);
if(tempV.getX() >= 0 && InGameState.getMap().isPosEmpty(tempV.getX(), tempV.getY()))
list.add(new AStarNode(tempV,this));
//*********Diagonal
tempV = new Vector2i(pos.getX()+1,pos.getY()+1);
if(tempV.getY() < InGameState.getMap().getSize().getY() &&
tempV.getX() < InGameState.getMap().getSize().getX() && InGameState.getMap().isPosEmpty(tempV.getX(), tempV.getY()))
list.add(new AStarNode(tempV,this));
tempV = new Vector2i(pos.getX()-1,pos.getY()-1);
if(tempV.getY() >= 0 && tempV.getX() >= 0 && InGameState.getMap().isPosEmpty(tempV.getX(), tempV.getY()))
list.add(new AStarNode(tempV,this));
tempV = new Vector2i(pos.getX()-1,pos.getY()+1);
if(tempV.getY() < InGameState.getMap().getSize().getY() &&
tempV.getX() >= 0 && InGameState.getMap().isPosEmpty(tempV.getX(), tempV.getY()))
list.add(new AStarNode(tempV,this));
tempV = new Vector2i(pos.getX()+1,pos.getY()-1);
if(tempV.getY() >= 0 &&
tempV.getX() < InGameState.getMap().getSize().getX() && InGameState.getMap().isPosEmpty(tempV.getX(), tempV.getY()))
list.add(new AStarNode(tempV,this));
return list;
}
}