Fix/Add tracked locations rotating on subcrafts

Movecraft/src/main/java/net/countercraft/movecraft/async/rotation/RotationTask.java

@@ -166,13 +166,13 @@ protected void execute() {
 
         // Rotates the craft's tracked locations, and all parent craft's.
         Craft temp = craft;
-        do {
-            for (Set<TrackedLocation> locations : craft.getTrackedLocations().values()) {
+        //do {
+            for (Set<TrackedLocation> locations : temp.getTrackedLocations().values()) {
                 for (TrackedLocation location : locations) {
                     location.rotate(rotation, originPoint);
                 }
             }
-        } while (temp instanceof SubCraft && (temp = ((SubCraft) temp).getParent()) != null);
+        //} while (temp instanceof SubCraft && (temp = ((SubCraft) temp).getParent()) != null);
 
         updates.add(new CraftRotateCommand(getCraft(),originPoint, rotation));
         //rotate entities in the craft

Movecraft/src/main/java/net/countercraft/movecraft/async/translation/TranslationTask.java

@@ -3,6 +3,7 @@
 import net.countercraft.movecraft.Movecraft;
 import net.countercraft.movecraft.MovecraftChunk;
 import net.countercraft.movecraft.MovecraftLocation;
+import net.countercraft.movecraft.TrackedLocation;
 import net.countercraft.movecraft.async.AsyncTask;
 import net.countercraft.movecraft.config.Settings;
 import net.countercraft.movecraft.craft.ChunkManager;
@@ -318,6 +319,8 @@ protected void execute() throws InterruptedException, ExecutionException {
             }
         }
 
+        updateTrackedLocations(craft, dx, dy, dz);
+
         if (!collisionBox.isEmpty() && craft.getType().getBoolProperty(CraftType.CRUISE_ON_PILOT)) {
             CraftManager.getInstance().release(craft, CraftReleaseEvent.Reason.EMPTY, false);
             for (MovecraftLocation location : oldHitBox) {
@@ -339,6 +342,16 @@ protected void execute() throws InterruptedException, ExecutionException {
         captureYield(harvestedBlocks);
     }
 
+    protected void updateTrackedLocations(Craft craft, int dx, int dy, int dz) {
+        craft.getTrackedLocations().values().forEach(trackedLocations -> {
+            trackedLocations.forEach(
+                    trackedLocation -> {
+                        trackedLocation.translate(dx, dy, dz);
+                    }
+            );
+        });
+    }
+
     private void preventsTorpedoRocketsPilots() {
         if (!craft.getType().getBoolProperty(CraftType.MOVE_ENTITIES) ||
                 (craft instanceof SinkingCraft

Movecraft/src/main/java/net/countercraft/movecraft/craft/BaseCraft.java

@@ -41,6 +41,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.logging.Level;
 
@@ -79,7 +80,7 @@ public abstract class BaseCraft implements Craft {
     private String name = "";
     @NotNull
     private MovecraftLocation lastTranslation = new MovecraftLocation(0, 0, 0);
-    private Map<NamespacedKey, Set<TrackedLocation>> trackedLocations = new HashMap<>();
+    private Map<NamespacedKey, Set<TrackedLocation>> trackedLocations = new ConcurrentHashMap<>();
 
     @NotNull
     private final CraftDataTagContainer dataTagContainer;

Movecraft/src/main/java/net/countercraft/movecraft/listener/CraftPilotListener.java

@@ -1,17 +1,27 @@
 package net.countercraft.movecraft.listener;
 
+import com.google.common.base.Predicates;
 import net.countercraft.movecraft.MovecraftLocation;
+import net.countercraft.movecraft.TrackedLocation;
 import net.countercraft.movecraft.craft.Craft;
+import net.countercraft.movecraft.craft.SubCraft;
 import net.countercraft.movecraft.events.CraftPilotEvent;
+import net.countercraft.movecraft.events.CraftReleaseEvent;
+import net.countercraft.movecraft.util.hitboxes.HitBox;
+import org.bukkit.NamespacedKey;
 import org.bukkit.block.Block;
 import org.bukkit.block.Sign;
 import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.*;
+import java.util.function.Predicate;
+
 public class CraftPilotListener implements Listener {
 
-    @EventHandler(ignoreCancelled = true)
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onCraftPilot(@NotNull CraftPilotEvent event) {
         // Walk through all signs and set a UUID in there
         final Craft craft = event.getCraft();
@@ -30,6 +40,91 @@ public void onCraftPilot(@NotNull CraftPilotEvent event) {
             craft.markTileStateWithUUID(tile);
             tile.update();
         }
+
+        // Tracked locations => Modify correctly with subcrafts
+        if (craft instanceof SubCraft subCraft && subCraft.getParent() != null) {
+            final Craft parent = subCraft.getParent();
+            if (parent.getWorld() != subCraft.getWorld()) {
+                return;
+            }
+            transferTrackedLocations(parent, subCraft, (trackedLocation) -> {
+                MovecraftLocation absolute = trackedLocation.getAbsoluteLocation();
+                if (subCraft.getHitBox().inBounds(absolute)) {
+                    if (subCraft.getHitBox().contains(absolute)) {
+                        return true;
+                    }
+                }
+                return false;
+            }, true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onCraftRelease(@NotNull CraftReleaseEvent event) {
+        if (event.getReason() != CraftReleaseEvent.Reason.SUB_CRAFT) {
+            return;
+        }
+        Craft released = event.getCraft();
+        if (!(released instanceof SubCraft)) {
+            return;
+        }
+        SubCraft subCraft = (SubCraft) released;
+        if (subCraft.getParent() == null) {
+            return;
+        }
+
+        // Attention: SquadronCrafts are also subcrafts! We need to make sure that they are at least intersecting the parent when we add back the tracked locations
+        final HitBox parentHitBox = subCraft.getParent().getHitBox();
+        final HitBox subCraftHitBox = subCraft.getHitBox();
+
+        if (!parentHitBox.inBounds(subCraftHitBox.getMinX(), subCraftHitBox.getMinY(), subCraftHitBox.getMinZ())) {
+            if (!parentHitBox.inBounds(subCraftHitBox.getMaxX(), subCraftHitBox.getMaxY(), subCraftHitBox.getMaxZ())) {
+                // Subcraft cant possible be within its parent anymore
+                return;
+            }
+        }
+
+        transferTrackedLocations(subCraft, subCraft.getParent(), Predicates.alwaysTrue(), true);
+    }
+
+    /*
+    * Transfers TrackedLocations from a craft A to a craft B with a optional filter.
+    * This MOVES the tracked locations, so keep that in mind
+    */
+    private static void transferTrackedLocations(final Craft a, final Craft b, Predicate<TrackedLocation> filterArgument, boolean move) {
+        final MovecraftLocation bMidPoint = b.getHitBox().getMidPoint();
+
+        for (Map.Entry<NamespacedKey, Set<TrackedLocation>> entry : a.getTrackedLocations().entrySet()) {
+            final Set<TrackedLocation> bTrackedLocations = b.getTrackedLocations().computeIfAbsent(entry.getKey(), k -> new HashSet<>());
+            final Set<TrackedLocation> aTrackedLocations = entry.getValue();
+
+            if (aTrackedLocations.isEmpty()) {
+                continue;
+            }
+
+            // Commented out code: previous attempt to actually transfer the tracked locations, which technically is unnecessary unless for subcrafts like squadrons that actually move!
+            List<TrackedLocation> transferred = new ArrayList<>();
+            aTrackedLocations.forEach(trackedLocation -> {
+                if (filterArgument.test(trackedLocation)) {
+                    if (move) {
+                        // Technically this (the reset call) is not necessary, but we will keep it here for potential extensions by third party addons
+                        final MovecraftLocation absoluteLocation = trackedLocation.getAbsoluteLocation();
+                        trackedLocation.reset(absoluteLocation);
+                        if (!(bTrackedLocations.add(trackedLocation))) {
+                            trackedLocation.reset(absoluteLocation);
+                        } else {
+                            transferred.add(trackedLocation);
+                        }
+                        if (!absoluteLocation.equals(trackedLocation.getAbsoluteLocation())) {
+                            throw new IllegalStateException("Somehow the previous and transferred absolute locations are NOT the same! This should NEVER happen!");
+                        }
+                    } else {
+                        bTrackedLocations.add(trackedLocation);
+                    }
+                }
+            });
+            aTrackedLocations.removeAll(transferred);
+        }
     }
 
 }

api/src/main/java/net/countercraft/movecraft/TrackedLocation.java

@@ -5,43 +5,73 @@
 import org.jetbrains.annotations.NotNull;
 
 public class TrackedLocation {
-    private MovecraftLocation offSet;
-    private final Craft craft;
+
+    private int x;
+    private int y;
+    private int z;
 
     /**
      * Creates a new TrackedLocation instance which tracks a location about a craft's midpoint.
-     * @param craft The craft that's that tied to the location.
      * @param location The absolute position to track. This location will be stored as a relative
      *                 location to the craft's central hitbox.
      */
+    public TrackedLocation(@NotNull MovecraftLocation location) {
+        reinit(location);
+    }
+
+    @Deprecated(forRemoval = true)
     public TrackedLocation(@NotNull Craft craft, @NotNull MovecraftLocation location) {
-        this.craft = craft;
-        MovecraftLocation midPoint = craft.getHitBox().getMidPoint();
-        offSet = location.subtract(midPoint);
+        this(location);
+    }
+
+    protected void reinit(@NotNull MovecraftLocation location) {
+        reinit(location.getX(), location.getY(), location.getZ());
+    }
+
+    protected void reinit(final int x, final int y, final int z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
     }
 
     /**
      * Rotates the stored location.
      * @param rotation A clockwise or counter-clockwise direction to rotate.
      */
     public void rotate(MovecraftRotation rotation, MovecraftLocation origin) {
-        offSet = MathUtils.rotateVec(rotation, getAbsoluteLocation().subtract(origin));
+        MovecraftLocation absolute = this.getAbsoluteLocation();
+        MovecraftLocation vector = MathUtils.rotateVec(rotation, absolute.subtract(origin));
+
+        MovecraftLocation newAbsolute = origin.add(vector);
+        reinit(newAbsolute);
+    }
+
+    public void translate(final int dx, final int dy, final int dz) {
+        this.x += dx;
+        this.y += dy;
+        this.z += dz;
     }
 
     /**
      * Gets the stored absolute location.
      * @return Returns the absolute location instead of a vector.
      */
     public MovecraftLocation getAbsoluteLocation() {
-        MovecraftLocation midPoint = craft.getHitBox().getMidPoint();
-        return offSet.add(midPoint);
+        return new MovecraftLocation(this.x, this. y, this.z);
     }
 
     /**
-     * Gets the stored location as a position vector relative to the midpoint.
-     * @return Returns the absolute location instead of a vector.
+     * NEVER USE THIS UNLESS ABSOLUTELY NECESSARY
+     * @param craft
+     * @param location
      */
-    public MovecraftLocation getOffSet() {
-        return offSet;
+    @Deprecated(forRemoval = true)
+    public void reset(@NotNull Craft craft, @NotNull MovecraftLocation location) {
+        reset(location);
     }
+
+    public void reset(@NotNull MovecraftLocation location) {
+        reinit(location);
+    }
+
 }