feat: added atDestinationProperty() to AStarMoveComponent, closes #945

Author: AlmasB

fxgl-entity/src/main/java/com/almasb/fxgl/pathfinding/astar/AStarMoveComponent.java

@@ -12,6 +12,8 @@
 import com.almasb.fxgl.entity.component.Component;
 import com.almasb.fxgl.entity.component.Required;
 import com.almasb.fxgl.pathfinding.CellMoveComponent;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
 import javafx.beans.value.ChangeListener;
 
 import java.util.ArrayList;
@@ -33,6 +35,8 @@ public final class AStarMoveComponent extends Component {
 
     private Runnable delayedPathCalc = EmptyRunnable.INSTANCE;
 
+    private ReadOnlyBooleanWrapper isAtDestinationProp = new ReadOnlyBooleanWrapper(true);
+
     private ChangeListener<Boolean> isAtDestinationListener = (o, old, isAtDestination) -> {
         if (isAtDestination) {
             delayedPathCalc.run();
@@ -71,11 +75,15 @@ public boolean isPathEmpty() {
         return path.isEmpty();
     }
 
+    public ReadOnlyBooleanProperty atDestinationProperty() {
+        return isAtDestinationProp.getReadOnlyProperty();
+    }
+
     /**
      * @return true when the path is empty and entity is no longer moving
      */
     public boolean isAtDestination() {
-        return !isMoving() && isPathEmpty();
+        return isAtDestinationProp.get();
     }
 
     public AStarGrid getGrid() {
@@ -99,6 +107,8 @@ public Optional<AStarCell> getCurrentCell() {
     public void stopMovementAt(int cellX, int cellY) {
         path.clear();
         moveComponent.setPositionToCell(cellX, cellY);
+
+        isAtDestinationProp.set(true);
     }
 
     public void stopMovement() {
@@ -153,6 +163,8 @@ public void moveToCell(int x, int y) {
      * This can be used to explicitly specify the start X and Y of the entity.
      */
     public void moveToCell(int startX, int startY, int targetX, int targetY) {
+        isAtDestinationProp.set(false);
+
         if (moveComponent.isAtDestination()) {
             path = pathfinder.get().findPath(startX, startY, targetX, targetY);
         } else {
@@ -162,6 +174,10 @@ public void moveToCell(int startX, int startY, int targetX, int targetY) {
 
     @Override
     public void onUpdate(double tpf) {
+        if (!isAtDestination() && !isMoving() && isPathEmpty()) {
+            isAtDestinationProp.set(true);
+        }
+
         if (path.isEmpty() || !moveComponent.isAtDestination())
             return;
 

fxgl-entity/src/test/kotlin/com/almasb/fxgl/pathfinding/astar/AStarMoveComponentTest.kt

@@ -151,6 +151,43 @@ class AStarMoveComponentTest {
         }
     }
 
+    @Test
+    fun `atDestinationProperty correctly reports changes`() {
+        var count = 0
+
+        aStarMoveComponent.atDestinationProperty().addListener { _, hasNotReached, hasReached ->
+            if (hasReached) {
+                count = 1
+            }
+
+            if (hasNotReached) {
+                count = -1
+            }
+        }
+
+        assertTrue(aStarMoveComponent.isAtDestination)
+        assertTrue(aStarMoveComponent.atDestinationProperty().value)
+
+        aStarMoveComponent.moveToCell(3, 0)
+
+        assertThat(count, `is`(-1))
+
+        repeat(50) {
+            cellMoveComponent.onUpdate(STEP_SIZE)
+            aStarMoveComponent.onUpdate(STEP_SIZE)
+        }
+
+        assertFalse(aStarMoveComponent.isAtDestination)
+        assertFalse(aStarMoveComponent.atDestinationProperty().value)
+        assertThat(count, `is`(-1))
+
+        finishMotion()
+
+        assertTrue(aStarMoveComponent.isAtDestination)
+        assertTrue(aStarMoveComponent.atDestinationProperty().value)
+        assertThat(count, `is`(1))
+    }
+
     private fun putComponentInMotion(x: Int, y: Int) {
         aStarMoveComponent.moveToCell(x, y)
         aStarMoveComponent.onUpdate(STEP_SIZE)

fxgl-samples/src/main/java/intermediate/ai/pathfinding/AStarPathfindingSample.java

@@ -0,0 +1,95 @@
+/*
+ * FXGL - JavaFX Game Library. The MIT License (MIT).
+ * Copyright (c) AlmasB ([email protected]).
+ * See LICENSE for details.
+ */
+
+package intermediate.ai.pathfinding;
+
+import com.almasb.fxgl.app.GameApplication;
+import com.almasb.fxgl.app.GameSettings;
+import com.almasb.fxgl.entity.Entity;
+import com.almasb.fxgl.pathfinding.CellMoveComponent;
+import com.almasb.fxgl.pathfinding.CellState;
+import com.almasb.fxgl.pathfinding.astar.AStarGrid;
+import com.almasb.fxgl.pathfinding.astar.AStarMoveComponent;
+import javafx.scene.input.MouseButton;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.shape.StrokeType;
+
+import static com.almasb.fxgl.dsl.FXGL.debug;
+import static com.almasb.fxgl.dsl.FXGL.entityBuilder;
+
+/**
+ * Demo that uses A* search to find a path between 2 cells in a grid.
+ * Right click to place a wall, left click to move.
+ *
+ * @author Almas Baimagambetov (AlmasB) ([email protected])
+ */
+public class AStarPathfindingSample extends GameApplication {
+
+    private Entity agent;
+
+    @Override
+    protected void initSettings(GameSettings settings) {
+        settings.setWidth(1280);
+        settings.setHeight(720);
+        settings.setDeveloperMenuEnabled(true);
+    }
+
+    @Override
+    protected void initGame() {
+        var grid = new AStarGrid(1280 / 40, 720 / 40);
+
+        agent = entityBuilder()
+                .viewWithBBox(new Rectangle(40, 40, Color.BLUE))
+                .with(new CellMoveComponent(40, 40, 150))
+                .with(new AStarMoveComponent(grid))
+                .zIndex(1)
+                .anchorFromCenter()
+                .buildAndAttach();
+
+        agent.getComponent(CellMoveComponent.class).atDestinationProperty().addListener((o, old, isAtDestination) -> {
+            if (isAtDestination) {
+                debug("CellMoveComponent: reached destination");
+            }
+        });
+
+        agent.getComponent(AStarMoveComponent.class).atDestinationProperty().addListener((o, old, isAtDestination) -> {
+            if (isAtDestination) {
+                debug("AStarMoveComponent: reached destination");
+            }
+        });
+
+        for (int y = 0; y < 720 / 40; y++) {
+            for (int x = 0; x < 1280 / 40; x++) {
+                final var finalX = x;
+                final var finalY = y;
+
+                var view = new Rectangle(40, 40, Color.WHITE);
+                view.setStroke(Color.color(0, 0, 0, 0.25));
+                view.setStrokeType(StrokeType.INSIDE);
+
+                var e = entityBuilder()
+                        .at(x * 40, y * 40)
+                        .view(view)
+                        .buildAndAttach();
+
+                e.getViewComponent().addOnClickHandler(event -> {
+                    if (event.getButton() == MouseButton.PRIMARY) {
+                        agent.getComponent(AStarMoveComponent.class).moveToCell(finalX, finalY);
+
+                    } else if (event.getButton() == MouseButton.SECONDARY) {
+                        grid.get(finalX, finalY).setState(CellState.NOT_WALKABLE);
+                        view.setFill(Color.RED);
+                    }
+                });
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        launch(args);
+    }
+}