Game Java: Algoritma A * (hanya mencari sel di depan karakter)
Jenis Game: peta kotak petak yang berbasis giliran
Petunjuk arah diperbolehkan: Kiri, Depan, Kanan (untuk membalikkan arah Anda harus menggunakan dua kiri atau dua kanan) - kiri dan kanan bergerak diagonal tetapi mengubah permukaan kapal tergantung pada permukaan aslinya)
Slot: Bergantung pada ukuran kapal, ada sejumlah slot untuk kapal tertentu yang dimasuki pengguna untuk memungkinkan kapal memindahkan banyak tempat per giliran (mis. 3 slot == 3 gerakan per giliran)
Contoh:
Posisi Awal: 2,2
Wajah awal: Utara
Pindah Ditempatkan: Kiri
Hasil Akhir: Posisi: 1,3; Wajah: Barat
Masalah: algoritma menggunakan semua 8 ubin untuk menemukan jalur; tetapi sebaiknya hanya mencari ubin yang ada di depan (tergantung pada permukaan kapal)
Kelas node:
public class AStarNode {
public Position position;
public VesselFace face;
public AStarNode parent;
public double fCost, gCost, hCost;
public AStarNode(Position position, VesselFace face, AStarNode parent, double gCost, double hCost) {
this.position = position;
this.face = face;
this.parent = parent;
this.gCost = gCost;
this.hCost = hCost;
this.fCost = this.gCost + this.hCost;
}
}
Perhitungan pencarian jalan:
private Comparator<AStarNode> nodeSorter = new Comparator<AStarNode>() {
@Override
public int compare(AStarNode n0, AStarNode n1) {
if(n1.fCost < n0.fCost) return 1;
if(n1.fCost > n0.fCost) return -1;
return 0;
}
};
public List<AStarNode> findPath(Position start, Position goal){
List<AStarNode> openList = new ArrayList<AStarNode>();
List<AStarNode> closedList = new ArrayList<AStarNode>();
AStarNode current = new AStarNode(start, null, 0, start.distance(goal));
openList.add(current);
while(openList.size() > 0) {
Collections.sort(openList, nodeSorter);
current = openList.get(0);
if(current.position.equals(goal)) {
List<AStarNode> path = new ArrayList<AStarNode>();
while(current.parent != null) {
path.add(current);
current = current.parent;
}
openList.clear();
closedList.clear();
return path;
}
openList.remove(current);
closedList.add(current);
for(int i = 0; i < 9; i++) {
if (i == 4)continue;
int x = current.position.getX();
int y = current.position.getY();
int xi = (i % 3) - 1;
int yi = (i / 3) - 1;
int at = context.getMap().getTile(x + xi, y + yi);
if(at == 1 || at == 2) continue; // ignore rocks
Position a = new Position(x + xi, y + yi);
double gCost = current.gCost + current.position.distance(a);
double hCost = a.distance(goal);
AStarNode node = new AStarNode(a, current, gCost, hCost);
if(positionInList(closedList, a) && gCost >= node.gCost) continue;
if(!positionInList(openList, a) || gCost < node.gCost) openList.add(node);
}
}
closedList.clear();
return null;
}
private boolean positionInList(List<AStarNode> list, Position position) {
for(AStarNode n : list) {
if(n.position.equals(position)) return true;
}
return false;
}
Penerapan:
@Override
public void calculateRoute() {
Position destination = new Position(3,3); // replace with cluster
if(this.equals(destination)) {
return;
}based
path = context.getPlayerManager().findPath(this, destination);
VesselFace face = getFace();
if(path != null) {
if(path.size() > 0) {
int numberOfMoves = getVessel().has3Moves() ? 3 : 4;
Position currentPosition = this.copy();
for(int slot = 0; slot <= numberOfMoves; slot++) { //moves to enter
int positionIndex = (path.size() - 1) - (slot); //subtract slot to allow multiple moves
if(positionIndex < 0 || path.size() < slot) { // make sure it doesn't count too far
return;
}
Position pos = path.get(positionIndex).position;
Position left = MoveType.LEFT.getFinalPosition(currentPosition, face);
Position right = MoveType.RIGHT.getFinalPosition(currentPosition, face);
Position forward = MoveType.FORWARD.getFinalPosition(currentPosition, face);
if(left.equals(pos)) {
currentPosition.add(left.getX() - getX(), left.getY() - getY());
getMoves().setMove(slot, MoveType.LEFT);
switch(face) {
case NORTH:
face = VesselFace.WEST;
break;
case SOUTH:
face = VesselFace.EAST;
break;
case WEST:
face = VesselFace.SOUTH;
break;
case EAST:
face = VesselFace.NORTH;
break;
}
}else if(right.equals(pos)) {
currentPosition.add(right.getX() - getX(), right.getY() - getY());
getMoves().setMove(slot, MoveType.RIGHT);
switch(face) {
case NORTH:
face = VesselFace.EAST;
break;
case SOUTH:
face = VesselFace.WEST;
break;
case WEST:
face = VesselFace.NORTH;
break;
case EAST:
face = VesselFace.SOUTH;
break;
}
}else if(forward.equals(pos)){
currentPosition.add(forward.getX() - getX(), forward.getY() - getY());
getMoves().setMove(slot, MoveType.FORWARD);
switch(face) {
case NORTH:
face = VesselFace.NORTH;
break;
case SOUTH:
face = VesselFace.SOUTH;
break;
case WEST:
face = VesselFace.WEST;
break;
case EAST:
face = VesselFace.EAST;
break;
}
}
}
}
}
}
Saya menggunakan pernyataan switch dan metode currentPosition.add () sehingga ketika Anda menempatkan 3 gerakan untuk belokan tertentu; ia tahu di mana ia harus berakhir. Mungkin bukan praktik terbaik.
Pernyataan yang menambahkan perpindahan ke slot tertentu
getMoves().setMove(slot, MoveType.FORWARD);
Ubin yang harus diperiksa setiap belokan berdasarkan permukaan kapal:
Jawaban
Ini hanya upaya parsial, memberikan detail lebih lanjut untuk komentar yang saya buat.
A * menelusuri grafik node yang berisi "status" kapal. Di sebagian besar tutorial (termasuk tutorial saya, maaf) statusnya hanya posisi. Tetapi dalam kasus Anda, saya pikir keadaannya adalah posisi dan arah hadapnya. Anda perlu mengetahui arah hadap untuk menghitung tiga posisi di depannya. Dan kemudian setelah pindah, Anda akan memiliki posisi dan arah hadap baru.
Nodesaat ini memiliki posisi; ubah untuk memiliki positiondan facing. Berikut adalah versi kasar dari for(int i = 0; i < 9; i++)pengulangan untuk menemukan tetangga. Alih-alih melalui 9 tetangga, masing-masing dari 4 arah akan memiliki tepat 3 tetangga. (Ya, ada 12, bukan 8! Karena tergantung arah mana yang Anda hadapi sebelumnya)
int x = current.position.getX();
int y = current.position.getY();
List<Node> neighbors = new ArrayList<Node>();
switch (current.facing) {
case NORTH:
neighbors.add(new Node(new Position(x-1, y-1), WEST, …));
neighbors.add(new Node(new Position(x, y-1), NORTH, …));
neighbors.add(new Node(new Position(x+1, y-1), EAST, …));
break;
case EAST:
neighbors.add(new Node(new Position(x+1, y-1), NORTH, …));
neighbors.add(new Node(new Position(x+1, y), EAST, …));
neighbors.add(new Node(new Position(x+1, y+1), SOUTH, …));
break;
case SOUTH:
neighbors.add(new Node(new Position(x-1, y+1), WEST, …));
neighbors.add(new Node(new Position(x, y+1), SOUTH, …));
neighbors.add(new Node(new Position(x+1, y+1), EAST, …));
break;
case WEST:
neighbors.add(new Node(new Position(x-1, y-1), NORTH, …));
neighbors.add(new Node(new Position(x-1, y), WEST, …));
neighbors.add(new Node(new Position(x-1, y+1), SOUTH, …));
break;
}
/* for each of the nodes in the neighbors list, use the same
logic you already have:
1. check if it's a rock, and ignore if it is
2. calculate g cost, store it in the node
3. calculate h cost, store it in the node
4. consider adding the node to openList
*/