Made it possible for more RCursors per player to be active

.gitignore

@@ -14,6 +14,7 @@ steamwar.properties
 # VSCode
 bin/
 .vscode
+.settings
 
 # Other
 lib

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/utils/cursor/RCursor.java

@@ -60,11 +60,13 @@ public class RCursor {
     }
 
     public void render() {
-        if (!visible) return;
+        if (!visible)
+            return;
 
         RayTraceUtils.RRayTraceResult rayTraceResult = RayTraceUtils.traceREntity(owner, owner.getLocation(), targetServer.getEntities());
         if (rayTraceResult == null) {
-            if(cursorEntity != null) cursorEntity.die();
+            if (cursorEntity != null)
+                cursorEntity.die();
             cursorEntity = null;
             return;
         }
@@ -84,7 +86,7 @@ public class RCursor {
         if (cursorEntity == null) {
             cursorEntity = new RFallingBlockEntity(cursorServer, activeCursorLocation, activeCursorMaterial);
             cursorEntity.setNoGravity(true);
-        } if (cursorEntity.getMaterial() == activeCursorMaterial) {
+        } else if (cursorEntity.getMaterial() == activeCursorMaterial) {
             cursorEntity.move(activeCursorLocation);
         } else {
             cursorEntity.die();
@@ -109,7 +111,8 @@ public class RCursor {
     }
 
     void handleClick(Action action) {
-        if(!visible || cursorLocation == null) return;
+        if (!visible || cursorLocation == null)
+            return;
 
         onClickHandler.handle(cursorLocation, isHittingEntity, action);
     }
@@ -152,8 +155,7 @@ public class RCursor {
             }
 
             return pos;
-        }, (player) -> player.isSneaking()),
+        }, (player) -> player.isSneaking()), BLOCK_ALIGNED(0, (player, rayTraceResult) -> {
-        BLOCK_ALIGNED(0, (player, rayTraceResult) -> {
             Vector pos = rayTraceResult.getHitPosition();
 
             BlockFace face = rayTraceResult.getHitBlockFace();

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/utils/cursor/RCursorManager.java

@@ -11,9 +11,10 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
-
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiFunction;
@@ -24,7 +25,7 @@ public class RCursorManager implements Listener {
     private static RCursorManager instance;
 
     private final Set<Player> calculationActive = new HashSet<>();
-    private final Map<Player, RCursor> activeCursors = new HashMap<>();
+    private final Map<Player, List<RCursor>> activeCursors = new HashMap<>();
 
     public RCursorManager() {
         if (instance == null) {
@@ -32,14 +33,14 @@ public class RCursorManager implements Listener {
         }
 
         BiFunction<Player, Object, Object> function = (player, object) -> {
-            updateCursor(player);
+            updateCursors(player);
             return object;
         };
 
         Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
             Set<Player> playersWithActiveCursor = activeCursors.keySet();
 
-            playersWithActiveCursor.forEach(this::updateCursor);
+            playersWithActiveCursor.forEach(this::updateCursors);
         }, 0);
 
         Class<?> positionPacketClass = Reflection.getClass("net.minecraft.network.protocol.game.ServerboundMovePlayerPacket$Pos");
@@ -52,26 +53,31 @@ public class RCursorManager implements Listener {
     }
 
     void registerCursor(RCursor cursor) {
-        closeCursorOf(cursor.getOwner());
+        List<RCursor> cursorsOfPlayer = activeCursors.getOrDefault(cursor.getOwner(), new ArrayList<>());
-
+        cursorsOfPlayer.add(cursor);
-        activeCursors.put(cursor.getOwner(), cursor);
+        activeCursors.put(cursor.getOwner(), cursorsOfPlayer);
     }
 
     void unregisterCursor(RCursor cursor) {
+        List<RCursor> cursorsOfPlayer = activeCursors.get(cursor.getOwner());
+        if (cursorsOfPlayer != null) {
+            cursorsOfPlayer.remove(cursor);
+            if (cursorsOfPlayer.isEmpty()) {
                 activeCursors.remove(cursor.getOwner());
             }
+        }
+    }
 
-    private void closeCursorOf(Player player) {
+    private void closeCursorsOf(Player player) {
-        RCursor currentPlayerCursor = activeCursors.get(player);
+        List<RCursor> cursorsOfPlayer = activeCursors.remove(player);
-
+        if (cursorsOfPlayer != null) {
-        if(currentPlayerCursor != null) {
+            new ArrayList<>(cursorsOfPlayer).forEach(RCursor::close);
-            currentPlayerCursor.close();
+        }
-        };
 
     }
 
 
-    private void updateCursor(Player player) {
+    private void updateCursors(Player player) {
         if (!activeCursors.containsKey(player)) {
             return;
         }
@@ -84,10 +90,10 @@ public class RCursorManager implements Listener {
             }
         }
 
-        RCursor cursor = activeCursors.get(player);
+        List<RCursor> cursors = activeCursors.get(player);
 
-        if (cursor != null) {
+        if (cursors != null) {
-            cursor.render();
+            cursors.forEach(RCursor::render);
         }
 
         synchronized (calculationActive) {
@@ -99,13 +105,14 @@ public class RCursorManager implements Listener {
     private void handlePlayerInteract(PlayerInteractEvent event) {
         Player player = event.getPlayer();
 
-        RCursor cursorOfPlayer = activeCursors.get(player);
+        List<RCursor> cursorsOfPlayer = activeCursors.get(player);
-
+        if (cursorsOfPlayer != null) {
-        cursorOfPlayer.handleClick(event.getAction());
+            cursorsOfPlayer.forEach(cursor -> cursor.handleClick(event.getAction()));
+        }
     }
 
     @EventHandler
     private void handlePlayerQuit(PlayerQuitEvent event) {
-        closeCursorOf(event.getPlayer());
+        closeCursorsOf(event.getPlayer());
     }
 }