Merge pull request #135 from TreemanKing/toggle-warp

feat: toggle warp command

src/main/java/world/bentobox/warps/Warp.java

@@ -17,6 +17,7 @@ import world.bentobox.bentobox.api.flags.clicklisteners.CycleClick;
 import world.bentobox.bentobox.managers.RanksManager;
 import world.bentobox.bentobox.util.Util;
 import world.bentobox.level.Level;
+import world.bentobox.warps.commands.ToggleWarpCommand;
 import world.bentobox.warps.commands.WarpCommand;
 import world.bentobox.warps.commands.WarpsCommand;
 import world.bentobox.warps.config.Settings;
@@ -100,6 +101,7 @@ public class Warp extends Addon {
             // Load the master warp and warps command
             new WarpCommand(this);
             new WarpsCommand(this);
+            new ToggleWarpCommand(this);
         }
     }
 
@@ -140,6 +142,7 @@ public class Warp extends Addon {
 
                 new WarpCommand(this, gameModeAddon.getPlayerCommand().get());
                 new WarpsCommand(this, gameModeAddon.getPlayerCommand().get());
+                new ToggleWarpCommand(this, gameModeAddon.getPlayerCommand().get());
                 this.hooked = true;
             }
         });
@@ -288,7 +291,7 @@ public class Warp extends Addon {
         }
         return switch (requestLabel) {
             case "getSortedWarps" -> getWarpSignsManager().getSortedWarps(world);
-            case "getWarp" -> uuid == null ? null : getWarpSignsManager().getWarp(world, uuid);
+            case "getWarp" -> uuid == null ? null : getWarpSignsManager().getWarpLocation(world, uuid);
             case "getWarpMap" -> getWarpSignsManager().getWarpMap(world);
             case "hasWarp" -> uuid == null ? null : getWarpSignsManager().hasWarp(world, uuid);
             case "listWarps" -> getWarpSignsManager().listWarps(world);

src/main/java/world/bentobox/warps/commands/ToggleWarpCommand.java

@@ -0,0 +1,61 @@
+package world.bentobox.warps.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import world.bentobox.bentobox.api.commands.CompositeCommand;
+import world.bentobox.bentobox.api.user.User;
+import world.bentobox.warps.Warp;
+import world.bentobox.warps.event.WarpToggleEvent;
+import world.bentobox.warps.objects.PlayerWarp;
+
+import java.util.List;
+import java.util.UUID;
+
+public class ToggleWarpCommand extends CompositeCommand {
+
+    private final Warp addon;
+
+    public ToggleWarpCommand(Warp addon, CompositeCommand bsbIslandCmd) {
+        super(bsbIslandCmd, addon.getSettings().getToggleWarpCommand());
+        this.addon = addon;
+    }
+
+    public ToggleWarpCommand(Warp addon) {
+        super(addon.getSettings().getToggleWarpCommand());
+        this.addon = addon;
+    }
+
+
+    @Override
+    public void setup() {
+        this.setPermission(this.getParent() == null ? Warp.WELCOME_WARP_SIGNS + ".togglewarp" : "island.warp.toggle");
+        this.setOnlyPlayer(true);
+        this.setDescription("togglewarp.help.description");
+    }
+
+    @Override
+    public boolean execute(User user, String s, List<String> list) {
+        UUID userUUID = user.getUniqueId();
+        World userWorld = user.getWorld();
+
+        // Check if the user has a warp
+        boolean hasWarp = addon.getWarpSignsManager().hasWarp(userWorld, userUUID);
+
+        if (hasWarp) {
+            // If the user has a warp, toggle its visibility
+            PlayerWarp warp = addon.getWarpSignsManager().getPlayerWarp(userWorld, userUUID);
+            // Check extreme case if PlayerWarp is null
+            if (warp == null) {
+                user.sendMessage("togglewarp.error.generic");
+                return false;
+            }
+            warp.toggle();
+            Bukkit.getPluginManager().callEvent(new WarpToggleEvent(userUUID, warp));
+            String message = warp.isEnabled() ? "togglewarp.enabled" : "togglewarp.disabled";
+            user.sendMessage(message);
+        } else {
+            user.sendMessage("togglewarp.error.no-warp");
+        }
+        return false;
+    }
+}

src/main/java/world/bentobox/warps/commands/WarpCommand.java

@@ -50,12 +50,12 @@ public class WarpCommand extends DelayedTeleportCommand {
                 user.sendMessage("warps.warpTip", "[text]", addon.getSettings().getWelcomeLine());
                 return false;
             } else {
-                // Attemp to find warp with exact player's name
+                // Attempt to find warp with exact player's name
                 UUID foundWarp = warpList.stream().filter(u -> getPlayers().getName(u).equalsIgnoreCase(args.get(0))).findFirst().orElse(null);
 
                 if (foundWarp == null) {
 
-                    // Atempt to find warp which starts with the given name
+                    // Attempt to find warp which starts with the given name
                     UUID foundAlernativeWarp = warpList.stream().filter(u -> getPlayers().getName(u).toLowerCase().startsWith(args.get(0).toLowerCase())).findFirst().orElse(null);
 
                     if (foundAlernativeWarp == null) {

src/main/java/world/bentobox/warps/config/Settings.java

@@ -61,6 +61,8 @@ public class Settings implements ConfigObject
     String warpCommand = "warp";
     @ConfigEntry(path = "warps-command")
     String warpsCommand = "warps";
+    @ConfigEntry(path = "togglewarp-command")
+    String toggleWarpCommand = "togglewarp";
 
     // ---------------------------------------------------------------------
     // Section: Constructor
@@ -205,6 +207,21 @@ public class Settings implements ConfigObject
         this.warpsCommand = warpsCommand;
     }
 
+
+    /**
+     * @return the toggleWarpCommand
+     */
+    public String getToggleWarpCommand() {
+        return toggleWarpCommand;
+    }
+
+    /**
+     * @param toggleWarpCommand the toggleWarpCommand to set
+     */
+    public void setToggleWarpCommand(String toggleWarpCommand) {
+        this.toggleWarpCommand = toggleWarpCommand;
+    }
+
     /**
      * @return the removeExistingWarpsWhenFlagChanges
      */

src/main/java/world/bentobox/warps/event/WarpToggleEvent.java

@@ -0,0 +1,72 @@
+package world.bentobox.warps.event;
+
+import org.bukkit.Location;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import world.bentobox.warps.objects.PlayerWarp;
+
+import java.util.UUID;
+
+/**
+ * This event is fired when a warp is toggled
+ * A Listener to this event can use it only to get information. e.g: broadcast something
+ *
+ * @since 1.16.0
+ * @author TreemanKing
+ */
+public class WarpToggleEvent extends Event {
+    private static final HandlerList handlers = new HandlerList();
+
+    private final UUID user;
+    private final PlayerWarp playerWarp;
+
+    public WarpToggleEvent(UUID user, PlayerWarp playerWarp) {
+        this.playerWarp = playerWarp;
+        this.user = user;
+    }
+
+    /**
+     * Gets the user who has toggled the warp
+     *
+     * @return the UUID of the player who toggled the warp
+     */
+    public UUID getUser() {
+        return user;
+    }
+
+    /**
+     * Gets the state of the warp
+     *
+     * @return true if the warp is enabled, false otherwise
+     */
+    public boolean isEnabled() {
+        return playerWarp.isEnabled();
+    }
+
+    /**
+     * Gets the PlayerWarp object
+     *
+     * @return the PlayerWarp object
+     */
+    public PlayerWarp getPlayerWarp() {
+        return playerWarp;
+    }
+
+    /**
+     * Gets the location of the toggled warp
+     *
+     * @return the location of the warp
+     */
+    public Location getLocation() {
+        return playerWarp.getLocation();
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+}

src/main/java/world/bentobox/warps/listeners/WarpSignsListener.java

@@ -28,6 +28,7 @@ import world.bentobox.bentobox.api.events.team.TeamLeaveEvent;
 import world.bentobox.bentobox.api.user.User;
 import world.bentobox.bentobox.database.objects.Island;
 import world.bentobox.bentobox.util.Util;
+import world.bentobox.warps.objects.PlayerWarp;
 import world.bentobox.warps.Warp;
 import world.bentobox.warps.event.WarpRemoveEvent;
 
@@ -60,12 +61,12 @@ public class WarpSignsListener implements Listener {
             @Override
             public void run() {
                 boolean changed = false;
-                Iterator<Map.Entry<UUID, Location>> iterator =
+                Iterator<Map.Entry<UUID, PlayerWarp>> iterator =
                         addon.getWarpSignsManager().getWarpMap(event.getWorld()).entrySet().iterator();
                 while (iterator.hasNext()) {
-                    Map.Entry<UUID, Location> entry = iterator.next();
+                    Map.Entry<UUID, PlayerWarp> entry = iterator.next();
                     UUID uuid = entry.getKey();
-                    Location location = entry.getValue();
+                    Location location = entry.getValue().getLocation();
                     if (event.getChunk().getX() == location.getBlockX() >> 4
                             && event.getChunk().getZ() == location.getBlockZ() >> 4
                             && !Tag.SIGNS.isTagged(location.getBlock().getType())) {
@@ -126,16 +127,16 @@ public class WarpSignsListener implements Listener {
 
     private boolean isPlayersSign(Player player, Block b, boolean inWorld) {
         // Welcome sign detected - check to see if it is this player's sign
-        Map<UUID, Location> list = addon.getWarpSignsManager().getWarpMap(b.getWorld());
+        Map<UUID, PlayerWarp> list = addon.getWarpSignsManager().getWarpMap(b.getWorld());
         String reqPerm = inWorld ? addon.getPermPrefix(b.getWorld()) + "mod.removesign" : Warp.WELCOME_WARP_SIGNS + ".mod.removesign";
-        return ((list.containsKey(player.getUniqueId()) && list.get(player.getUniqueId()).equals(b.getLocation()))
+        return ((list.containsKey(player.getUniqueId()) && list.get(player.getUniqueId()).getLocation().equals(b.getLocation()))
                 || player.isOp()  || player.hasPermission(reqPerm));
     }
 
     private boolean isWarpSign(Block b) {
         Sign s = (Sign) b.getState();
         return s.getLine(0).equalsIgnoreCase(ChatColor.GREEN + addon.getSettings().getWelcomeLine())
-                && addon.getWarpSignsManager().getWarpMap(b.getWorld()).containsValue(s.getLocation());
+                && addon.getWarpSignsManager().getWarpMap(b.getWorld()).values().stream().anyMatch(playerWarp -> playerWarp.getLocation().equals(s.getLocation()));
     }
 
     /**
@@ -175,7 +176,7 @@ public class WarpSignsListener implements Listener {
             }
 
             // Check if the player already has a sign
-            final Location oldSignLoc = addon.getWarpSignsManager().getWarp(b.getWorld(), user.getUniqueId());
+            final Location oldSignLoc = addon.getWarpSignsManager().getWarpLocation(b.getWorld(), user.getUniqueId());
             if (oldSignLoc != null) {
                 // A sign already exists. Check if it still there and if
                 // so,
@@ -221,15 +222,15 @@ public class WarpSignsListener implements Listener {
 
         final Island island = e.getIsland();
 
-        final Map<UUID, Location> islandWarps = addon
+        final Map<UUID, PlayerWarp> islandWarps = addon
                 .getWarpSignsManager()
                 .getWarpMap(island.getWorld())
                 .entrySet()
                 .stream()
-                .filter(x -> island.inIslandSpace(x.getValue()))
+                .filter(x -> island.inIslandSpace(x.getValue().getLocation()))
                 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
 
-        for(Map.Entry<UUID, Location> entry : islandWarps.entrySet()) {
+        for(Map.Entry<UUID, PlayerWarp> entry : islandWarps.entrySet()) {
             if(island.getRank(entry.getKey()) >= e.getSetTo()) continue;
 
             //The user has a lower rank than the new set value.

src/main/java/world/bentobox/warps/managers/WarpSignsManager.java

@@ -37,6 +37,7 @@ import world.bentobox.bentobox.database.Database;
 import world.bentobox.bentobox.database.objects.Island;
 import world.bentobox.bentobox.lists.Flags;
 import world.bentobox.bentobox.util.Util;
+import world.bentobox.warps.objects.PlayerWarp;
 import world.bentobox.warps.Warp;
 import world.bentobox.warps.event.WarpCreateEvent;
 import world.bentobox.warps.event.WarpInitiateEvent;
@@ -55,7 +56,7 @@ public class WarpSignsManager {
     private static final String WARPS = "warps";
     private final BentoBox plugin;
     // Map of all warps stored as player, warp sign Location
-    private Map<World, Map<UUID, Location>> worldsWarpList;
+    private Map<World, Map<UUID, PlayerWarp>> worldsWarpList;
     // Database handler for level data
     private final Database<WarpsData> handler;
 
@@ -68,7 +69,7 @@ public class WarpSignsManager {
      * @return map of warps
      */
     @NonNull
-    public Map<UUID, Location> getWarpMap(@Nullable World world) {
+    public Map<UUID, PlayerWarp> getWarpMap(@Nullable World world) {
         return worldsWarpList.computeIfAbsent(Util.getWorld(world), k -> new HashMap<>());
     }
 
@@ -100,11 +101,13 @@ public class WarpSignsManager {
             return false;
         }
         // Check for warps placed in a location where there was a warp before
-        if (getWarpMap(loc.getWorld()).containsValue(loc)) {
+        for (PlayerWarp playerWarp : getWarpMap(loc.getWorld()).values()) {
-            // remove the warp at this location, then place it
+            if (playerWarp.getLocation().equals(loc)) {
                 this.removeWarp(loc);
+                break;
             }
-        getWarpMap(loc.getWorld()).put(playerUUID, loc);
+        }
+        getWarpMap(loc.getWorld()).put(playerUUID, new PlayerWarp(loc, true));
         saveWarpList();
         Bukkit.getPluginManager().callEvent(new WarpCreateEvent(addon, loc, playerUUID));
         return true;
@@ -119,7 +122,13 @@ public class WarpSignsManager {
      * @return Location of warp or null
      */
     @Nullable
-    public Location getWarp(World world, UUID playerUUID) {
+    public Location getWarpLocation(World world, UUID playerUUID) {
+        PlayerWarp playerWarp = getWarpMap(world).get(playerUUID);
+        return playerWarp != null ? playerWarp.getLocation() : null;
+    }
+
+    @Nullable
+    public PlayerWarp getPlayerWarp(World world, UUID playerUUID) {
         return getWarpMap(world).get(playerUUID);
     }
 
@@ -130,7 +139,7 @@ public class WarpSignsManager {
      */
     @NonNull
     public String getWarpOwner(Location location) {
-        return getWarpMap(location.getWorld()).entrySet().stream().filter(en -> en.getValue().equals(location))
+        return getWarpMap(location.getWorld()).entrySet().stream().filter(en -> en.getValue().getLocation().equals(location))
                 .findFirst().map(en -> plugin.getPlayers().getName(en.getKey())).orElse("");
     }
 
@@ -140,7 +149,7 @@ public class WarpSignsManager {
      * @return Optional UUID of warp owner or empty if there is none
      */
     public Optional<UUID> getWarpOwnerUUID(Location location) {
-        return getWarpMap(location.getWorld()).entrySet().stream().filter(en -> en.getValue().equals(location))
+        return getWarpMap(location.getWorld()).entrySet().stream().filter(en -> en.getValue().getLocation().equals(location))
                 .findFirst().map(Map.Entry::getKey);
     }
 
@@ -160,6 +169,10 @@ public class WarpSignsManager {
         // Bigger value of time means a more recent login
         TreeMap<Long, UUID> map = new TreeMap<>();
         getWarpMap(world).forEach((uuid, value) -> {
+            // If the warp is not enabled, skip this iteration
+            if (!value.isEnabled()) {
+                return;
+            }
             // If never played, will be zero
             long lastPlayed = addon.getServer().getOfflinePlayer(uuid).getLastPlayed();
             // This aims to avoid the chance that players logged off at exactly the same time
@@ -188,7 +201,11 @@ public class WarpSignsManager {
     public Set<UUID> listWarps(@NonNull World world) {
         // Remove any null locations
         getWarpMap(world).values().removeIf(Objects::isNull);
-        return getWarpMap(world).entrySet().stream().filter(e -> Util.sameWorld(world, Objects.requireNonNull(e.getValue().getWorld()))).map(Map.Entry::getKey).collect(Collectors.toSet());
+        // Remove any warps that have not been toggled on
+        Map<UUID, PlayerWarp> enabledWarps = getWarpMap(world).entrySet().stream()
+                .filter(entry -> entry.getValue().isEnabled())
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+        return enabledWarps.keySet();
     }
 
     /**
@@ -201,7 +218,8 @@ public class WarpSignsManager {
             warpsData = handler.loadObject(WARPS);
             // Load into map
             if (warpsData != null) {
-                warpsData.getWarpSigns().forEach((location,uuid) -> {
+                warpsData.getWarpSigns().forEach((pw, uuid) -> {
+                    Location location = pw.getLocation();
                     if (location != null && location.getWorld() != null) {
                         if (location.getWorld().isChunkLoaded(location.getBlockX() >> 4, location.getBlockZ() >> 4)
                                 && !location.getBlock().getType().name().contains("SIGN")) {
@@ -209,7 +227,7 @@ public class WarpSignsManager {
                         }
 
                         // Add to map
-                        getWarpMap(location.getWorld()).put(uuid, location);
+                        getWarpMap(location.getWorld()).put(uuid, new PlayerWarp(location, true));
                     }
                 });
             } else {
@@ -240,10 +258,10 @@ public class WarpSignsManager {
      */
     public void removeWarp(Location loc) {
         popSign(loc);
-        Iterator<Entry<UUID, Location>> it = getWarpMap(loc.getWorld()).entrySet().iterator();
+        Iterator<Entry<UUID, PlayerWarp>> it = getWarpMap(loc.getWorld()).entrySet().iterator();
         while (it.hasNext()) {
-            Entry<UUID, Location> en = it.next();
+            Entry<UUID, PlayerWarp> en = it.next();
-            if (en.getValue().equals(loc)) {
+            if (en.getValue().getLocation().equals(loc)) {
                 // Inform player
                 Optional.ofNullable(addon.getServer().getPlayer(en.getKey()))
                 .map(User::getInstance)
@@ -263,7 +281,7 @@ public class WarpSignsManager {
      */
     public void removeWarp(World world, UUID uuid) {
         if (getWarpMap(world).containsKey(uuid)) {
-            popSign(getWarpMap(world).get(uuid));
+            popSign(getWarpMap(world).get(uuid).getLocation());
             getWarpMap(world).remove(uuid);
 
         }
@@ -299,7 +317,7 @@ public class WarpSignsManager {
     @NonNull
     public SignCacheItem getSignInfo(@NonNull World world, @NonNull UUID uuid) {
         //get the sign info
-        Location signLocation = getWarp(world, uuid);
+        Location signLocation = getWarpLocation(world, uuid);
         if (signLocation == null || !signLocation.getBlock().getType().name().contains("SIGN")) {
             return new SignCacheItem();
         }
@@ -393,7 +411,7 @@ public class WarpSignsManager {
      * @param owner - owner of the warp
      */
     public void warpPlayer(@NonNull World world, @NonNull User user, @NonNull UUID owner) {
-        final Location warpSpot = getWarp(world, owner);
+        final Location warpSpot = getWarpLocation(world, owner);
         // Check if the warp spot is safe
         if (warpSpot == null) {
             user.sendMessage("warps.error.does-not-exist");

src/main/java/world/bentobox/warps/objects/PlayerWarp.java

@@ -0,0 +1,32 @@
+package world.bentobox.warps.objects;
+
+import com.google.gson.annotations.Expose;
+import org.bukkit.Location;
+
+import java.io.Serializable;
+
+public class PlayerWarp implements Serializable {
+
+    @Expose
+    private final Location location;
+
+    @Expose
+    private boolean isEnabled;
+
+    public PlayerWarp(Location location, boolean isEnabled) {
+        this.location = location;
+        this.isEnabled = isEnabled;
+    }
+
+    public Location getLocation() {
+        return location;
+    }
+
+    public boolean isEnabled() {
+        return isEnabled;
+    }
+
+    public void toggle() {
+        isEnabled = !isEnabled;
+    }
+}

src/main/java/world/bentobox/warps/objects/WarpsData.java

@@ -17,9 +17,13 @@ public class WarpsData implements DataObject {
 
     @Expose
     private String uniqueId = "warps";
-    @Expose
+
+    @Deprecated @Expose
     private Map<Location, UUID> warpSigns = new HashMap<>();
 
+    @Expose
+    private Map<PlayerWarp, UUID> newWarpSigns = new HashMap<>();
+
     public WarpsData() {
         // Required by YAML database
     }
@@ -34,24 +38,40 @@ public class WarpsData implements DataObject {
         this.uniqueId = uniqueId;
     }
 
-    public Map<Location,  UUID> getWarpSigns() {
+    public Map<PlayerWarp,  UUID> getWarpSigns() {
-        if (warpSigns == null)
+        convertOldWarpSigns();
+        if (newWarpSigns == null)
             return new HashMap<>();
-        return warpSigns;
+        return newWarpSigns;
-    }
-
-    public void setWarpSigns(Map<Location, UUID> warpSigns) {
-        this.warpSigns = warpSigns;
     }
 
     /**
-     * Puts all the data from the map into this objects ready for saving
+     * Method for converting old warp signs to new warp signs
+     */
+    public void convertOldWarpSigns() {
+        if (warpSigns == null) {
+            return;
+        }
+
+        for (Map.Entry<Location, UUID> entry : warpSigns.entrySet()) {
+            PlayerWarp playerWarp = new PlayerWarp(entry.getKey(), true);
+            newWarpSigns.put(playerWarp, entry.getValue());
+        }
+        warpSigns = null;
+    }
+
+    public void setWarpSigns(Map<PlayerWarp, UUID> warpSigns) {
+        this.newWarpSigns = warpSigns;
+    }
+
+    /**
+     * Puts all the data from the map into these objects ready for saving
      * @param worldsWarpList 2D map of warp locations by world vs UUID
      * @return this class filled with data
      */
-    public WarpsData save(Map<World, Map<UUID, Location>> worldsWarpList) {
+    public WarpsData save(Map<World, Map<UUID, PlayerWarp>> worldsWarpList) {
         getWarpSigns().clear();
-        worldsWarpList.values().forEach(world -> world.forEach((uuid,location) -> warpSigns.put(location, uuid)));
+        worldsWarpList.values().forEach(world -> world.forEach((uuid,playerWarp) -> newWarpSigns.put(playerWarp, uuid)));
         return this;
     }
 

src/main/java/world/bentobox/warps/panels/Utils.java

@@ -52,7 +52,7 @@ public class Utils
             List<String> permissions = user.getEffectivePermissions().stream().
                 map(PermissionAttachmentInfo::getPermission).
                 filter(permission -> permission.startsWith(permPrefix)).
-                collect(Collectors.toList());
+                    toList();
 
             for (String permission : permissions)
             {

src/main/resources/addon.yml

@@ -18,3 +18,6 @@ permissions:
   '[gamemode].island.addwarp':
     description: Player can create a welcome warp sign
     default: true
+  '[gamemode].island.togglewarp':
+    description: Player can toggle a warp sign
+    default: true

src/main/resources/config.yml

@@ -33,3 +33,4 @@ allow-in-other-worlds: false
 # Warp and warps commands. You can change them if they clash with other addons or plugins.
 warp-command: warp
 warps-command: warps
+togglewarp-command: togglewarp

src/main/resources/locales/en-US.yml

@@ -60,6 +60,16 @@ warps:
     # Prefix for messages that are send from server.
     prefix: "&l&6 [BentoBox]: &r"
 
+togglewarp:
+  help:
+    description: "toggle the warp sign"
+  enabled: "&a Your warp is now visible!"
+  disabled: "&c Your warp is now hidden!"
+  error:
+    no-permission: "&c You do not have permission to do that!"
+    generic: "&c An error occurred while toggling your warp."
+    no-warp: "&c You do not have a warp to toggle!"
+
 protection:
   flags:
     PLACE_WARP:

src/test/java/world/bentobox/warps/WarpSignsManagerTest.java

@@ -67,6 +67,7 @@ import world.bentobox.warps.event.WarpCreateEvent;
 import world.bentobox.warps.event.WarpInitiateEvent;
 import world.bentobox.warps.managers.SignCacheManager;
 import world.bentobox.warps.managers.WarpSignsManager;
+import world.bentobox.warps.objects.PlayerWarp;
 import world.bentobox.warps.objects.WarpsData;
 
 
@@ -195,7 +196,7 @@ public class WarpSignsManagerTest {
 
         // Handler
         when(handler.objectExists("warps")).thenReturn(true);
-        Map<Location, UUID> warpMap = Collections.singletonMap(location, uuid);
+        Map<PlayerWarp, UUID> warpMap = Collections.singletonMap(new PlayerWarp(location, true), uuid);
         when(load.getWarpSigns()).thenReturn(warpMap);
         when(handler.loadObject(anyString())).thenReturn(load);
 
@@ -275,7 +276,8 @@ public class WarpSignsManagerTest {
      */
     @Test
     public void testGetWarpMapNullLocation() {
-        Map<Location, UUID> warpMap = Collections.singletonMap(null, uuid);
+        PlayerWarp playerWarp = new PlayerWarp(null, true);
+        Map<PlayerWarp, UUID> warpMap = Collections.singletonMap(playerWarp, uuid);
         when(load.getWarpSigns()).thenReturn(warpMap);
         wsm = new WarpSignsManager(addon, plugin);
         assertTrue("Map is not empty", wsm.getWarpMap(world).isEmpty());
@@ -357,19 +359,19 @@ public class WarpSignsManagerTest {
     }
 
     /**
-     * Test method for {@link WarpSignsManager#getWarp(org.bukkit.World, java.util.UUID)}.
+     * Test method for {@link WarpSignsManager#getWarpLocation(org.bukkit.World, java.util.UUID)}.
      */
     @Test
     public void testGetWarpWorldWorld() {
-        assertNull(wsm.getWarp(mock(World.class), uuid));
+        assertNull(wsm.getWarpLocation(mock(World.class), uuid));
     }
 
     /**
-     * Test method for {@link WarpSignsManager#getWarp(org.bukkit.World, java.util.UUID)}.
+     * Test method for {@link WarpSignsManager#getWarpLocation(org.bukkit.World, java.util.UUID)}.
      */
     @Test
     public void testGetWarp() {
-        assertEquals(location, wsm.getWarp(world, uuid));
+        assertEquals(location, wsm.getWarpLocation(world, uuid));
     }
 
     /**

src/test/java/world/bentobox/warps/listeners/WarpSignsListenerTest.java

@@ -50,6 +50,7 @@ import world.bentobox.bentobox.managers.IslandsManager;
 import world.bentobox.bentobox.managers.LocalesManager;
 import world.bentobox.bentobox.managers.PlaceholdersManager;
 import world.bentobox.bentobox.util.Util;
+import world.bentobox.warps.objects.PlayerWarp;
 import world.bentobox.warps.Warp;
 import world.bentobox.warps.managers.WarpSignsManager;
 import world.bentobox.warps.config.Settings;
@@ -123,16 +124,16 @@ public class WarpSignsListenerTest {
         when(block.getState()).thenReturn(s);
         // warp signs manager
         when(addon.getWarpSignsManager()).thenReturn(wsm);
-        Map<UUID, Location> list = new HashMap<>();
+        Map<UUID, PlayerWarp> list = new HashMap<>();
         Location location = mock(Location.class);
         when(location.getBlock()).thenReturn(block);
         when(s.getLocation()).thenReturn(location);
         when(block.getLocation()).thenReturn(location);
-        list.put(uuid, location);
+        list.put(uuid, new PlayerWarp(location, true));
         // Player is in world
         when(wsm.getWarpMap(world)).thenReturn(list);
         //Player has a warp sign already here
-        when(wsm.getWarp(any(), any())).thenReturn(location);
+        when(wsm.getWarpLocation(any(), any())).thenReturn(location);
         // Unique spot
         when(wsm.addWarp(any(), any())).thenReturn(true);
         // Bentobox
@@ -339,8 +340,8 @@ public class WarpSignsListenerTest {
         when(settings.getRemoveExistingWarpsWhenFlagChanges()).thenReturn(true);
         WarpSignsListener wsl = new WarpSignsListener(addon);
 
-        Map<UUID, Location> warps = Map.of(
+        Map<UUID, PlayerWarp> warps = Map.of(
-                player.getUniqueId(), block.getLocation()
+                player.getUniqueId(), new PlayerWarp(block.getLocation(), true)
         );
 
         when(wsm.getWarpMap(any())).thenReturn(warps);
@@ -420,7 +421,7 @@ public class WarpSignsListenerTest {
 
     @Test
     public void testCreateNoSignAlreadyUniqueSpot() {
-        when(wsm.getWarp(any(), any())).thenReturn(null);
+        when(wsm.getWarpLocation(any(), any())).thenReturn(null);
         when(player.hasPermission(anyString())).thenReturn(true);
         WarpSignsListener wsl = new WarpSignsListener(addon);
         SignChangeEvent e = new SignChangeEvent(block, player, lines);