Upload folder via GUI - src

src/main/java/de/teleportsuite/managers/HomeManager.java

@@ -0,0 +1,53 @@
+package de.teleportsuite.managers;
+
+import de.teleportsuite.TeleportSuite;
+import de.teleportsuite.models.Home;
+import de.teleportsuite.models.TeleportLocation;
+import org.bukkit.entity.Player;
+import java.util.List;
+import java.util.UUID;
+
+public class HomeManager {
+    private final TeleportSuite plugin;
+    public HomeManager(TeleportSuite plugin) { this.plugin = plugin; }
+
+    public int getMaxHomes(Player player) {
+        if (player.hasPermission("teleportsuite.home.unlimited")) return Integer.MAX_VALUE;
+        if (player.hasPermission("teleportsuite.home.premium")) return plugin.getConfigManager().getMaxHomes("premium");
+        if (player.hasPermission("teleportsuite.home.vip")) return plugin.getConfigManager().getMaxHomes("vip");
+        return plugin.getConfigManager().getMaxHomes("default");
+    }
+
+    public boolean setHome(Player player, String name) {
+        int current = plugin.getDatabaseManager().countHomes(player.getUniqueId());
+        int max = getMaxHomes(player);
+        if (current >= max) {
+            player.sendMessage(plugin.getConfigManager().getMessage("home-limit", "max", String.valueOf(max)));
+            return false;
+        }
+        TeleportLocation loc = new TeleportLocation(player.getLocation(), plugin.getConfigManager().getServerName());
+        plugin.getDatabaseManager().saveHome(player.getUniqueId(), name, loc);
+        player.sendMessage(plugin.getConfigManager().getMessage("home-set", "name", name));
+        return true;
+    }
+
+    public void teleportHome(Player player, String name) {
+        Home home = plugin.getDatabaseManager().getHome(player.getUniqueId(), name);
+        if (home == null) {
+            player.sendMessage(plugin.getConfigManager().getMessage("home-not-found", "name", name));
+            return;
+        }
+        plugin.getTeleportManager().teleport(player, home.getLocation());
+    }
+
+    public boolean deleteHome(Player player, String name) {
+        boolean deleted = plugin.getDatabaseManager().deleteHome(player.getUniqueId(), name);
+        if (deleted) player.sendMessage(plugin.getConfigManager().getMessage("home-deleted", "name", name));
+        else player.sendMessage(plugin.getConfigManager().getMessage("home-not-found", "name", name));
+        return deleted;
+    }
+
+    public List<Home> getHomes(UUID uuid) {
+        return plugin.getDatabaseManager().getHomes(uuid);
+    }
+}

src/main/java/de/teleportsuite/managers/PortalManager.java

@@ -0,0 +1,81 @@
+package de.teleportsuite.managers;
+
+import de.teleportsuite.TeleportSuite;
+import de.teleportsuite.models.Portal;
+import de.teleportsuite.models.TeleportLocation;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import java.util.*;
+
+public class PortalManager {
+    private final TeleportSuite plugin;
+    private List<Portal> portals = new ArrayList<>();
+    // Selection for portal creation: player -> pos1, pos2
+    private final Map<UUID, Location> pos1 = new HashMap<>();
+    private final Map<UUID, Location> pos2 = new HashMap<>();
+    // Cooldown to prevent multiple triggers
+    private final Map<UUID, Long> cooldown = new HashMap<>();
+
+    public PortalManager(TeleportSuite plugin) {
+        this.plugin = plugin;
+        loadPortals();
+    }
+
+    public void loadPortals() {
+        portals = plugin.getDatabaseManager().getAllPortals();
+    }
+
+    public void setPos1(Player player, Location loc) {
+        pos1.put(player.getUniqueId(), loc);
+        player.sendMessage("§aPos1 gesetzt: §f" + formatLoc(loc));
+    }
+
+    public void setPos2(Player player, Location loc) {
+        pos2.put(player.getUniqueId(), loc);
+        player.sendMessage("§aPos2 gesetzt: §f" + formatLoc(loc));
+    }
+
+    public boolean createPortal(Player player, String name, String targetServer, String targetWorld, double tx, double ty, double tz) {
+        Location l1 = pos1.get(player.getUniqueId());
+        Location l2 = pos2.get(player.getUniqueId());
+        if (l1 == null || l2 == null) {
+            player.sendMessage("§cBitte setze erst Pos1 und Pos2 mit §e/setportal pos1 §cund §e/setportal pos2");
+            return false;
+        }
+        TeleportLocation dest = new TeleportLocation(targetWorld, tx, ty, tz, 0, 0, targetServer);
+        Portal portal = new Portal(name, l1.getWorld().getName(),
+                l1.getBlockX(), l1.getBlockY(), l1.getBlockZ(),
+                l2.getBlockX(), l2.getBlockY(), l2.getBlockZ(),
+                targetServer, dest);
+        plugin.getDatabaseManager().savePortal(portal);
+        portals.add(portal);
+        pos1.remove(player.getUniqueId());
+        pos2.remove(player.getUniqueId());
+        player.sendMessage(plugin.getConfigManager().getMessage("portal-created", "name", name));
+        return true;
+    }
+
+    public boolean deletePortal(String name) {
+        portals.removeIf(p -> p.getName().equalsIgnoreCase(name));
+        return plugin.getDatabaseManager().deletePortal(name);
+    }
+
+    public void checkPortal(Player player, Location loc) {
+        long now = System.currentTimeMillis();
+        if (now - cooldown.getOrDefault(player.getUniqueId(), 0L) < 2000) return;
+
+        for (Portal portal : portals) {
+            if (portal.contains(loc)) {
+                cooldown.put(player.getUniqueId(), now);
+                plugin.getTeleportManager().teleport(player, portal.getDestination(), true);
+                break;
+            }
+        }
+    }
+
+    public List<Portal> getPortals() { return portals; }
+
+    private String formatLoc(Location loc) {
+        return loc.getBlockX() + ", " + loc.getBlockY() + ", " + loc.getBlockZ() + " in " + loc.getWorld().getName();
+    }
+}

src/main/java/de/teleportsuite/managers/SavePointManager.java

@@ -0,0 +1,22 @@
+package de.teleportsuite.managers;
+
+import de.teleportsuite.TeleportSuite;
+import de.teleportsuite.models.TeleportLocation;
+import org.bukkit.entity.Player;
+
+public class SavePointManager {
+    private final TeleportSuite plugin;
+    public SavePointManager(TeleportSuite plugin) { this.plugin = plugin; }
+
+    public void setSavePoint(Player player, String name) {
+        TeleportLocation loc = new TeleportLocation(player.getLocation(), plugin.getConfigManager().getServerName());
+        plugin.getDatabaseManager().saveSavePoint(player.getUniqueId(), name, loc);
+        player.sendMessage(plugin.getConfigManager().getMessage("savepoint-set", "name", name));
+    }
+
+    public void teleportToSavePoint(Player player, String name) {
+        TeleportLocation loc = plugin.getDatabaseManager().getSavePoint(player.getUniqueId(), name);
+        if (loc == null) { player.sendMessage("§cSavepoint §6" + name + " §cnicht gefunden."); return; }
+        plugin.getTeleportManager().teleport(player, loc);
+    }
+}

src/main/java/de/teleportsuite/managers/SpawnManager.java

@@ -0,0 +1,41 @@
+package de.teleportsuite.managers;
+
+import de.teleportsuite.TeleportSuite;
+import de.teleportsuite.models.TeleportLocation;
+import org.bukkit.entity.Player;
+
+public class SpawnManager {
+    private final TeleportSuite plugin;
+    public SpawnManager(TeleportSuite plugin) { this.plugin = plugin; }
+
+    public void setSpawn(Player player) {
+        TeleportLocation loc = new TeleportLocation(player.getLocation(), plugin.getConfigManager().getServerName());
+        plugin.getDatabaseManager().saveSpawn("spawn", loc);
+        player.sendMessage(plugin.getConfigManager().getMessage("spawn-set"));
+    }
+
+    public void setFirstSpawn(Player player) {
+        TeleportLocation loc = new TeleportLocation(player.getLocation(), plugin.getConfigManager().getServerName());
+        plugin.getDatabaseManager().saveSpawn("firstspawn", loc);
+        player.sendMessage(plugin.getConfigManager().getMessage("firstspawn-set"));
+    }
+
+    public void teleportToSpawn(Player player) {
+        TeleportLocation spawn = plugin.getDatabaseManager().getSpawn("spawn");
+        if (spawn == null) { player.sendMessage("§cKein Spawn gesetzt!"); return; }
+        plugin.getTeleportManager().teleport(player, spawn);
+    }
+
+    public void teleportToFirstSpawn(Player player) {
+        TeleportLocation firstSpawn = plugin.getDatabaseManager().getSpawn("firstspawn");
+        if (firstSpawn == null) {
+            teleportToSpawn(player);
+            return;
+        }
+        plugin.getTeleportManager().teleport(player, firstSpawn);
+    }
+
+    public TeleportLocation getRespawnLocation() {
+        return plugin.getDatabaseManager().getSpawn("spawn");
+    }
+}

src/main/java/de/teleportsuite/managers/TeleportManager.java

@@ -0,0 +1,164 @@
+package de.teleportsuite.managers;
+
+import de.teleportsuite.TeleportSuite;
+import de.teleportsuite.models.TeleportLocation;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+
+import java.util.*;
+
+public class TeleportManager {
+    private final TeleportSuite plugin;
+    // Pending TPA requests: requester -> target
+    private final Map<UUID, UUID> tpaRequests = new HashMap<>();
+    private final Map<UUID, Long> requestTimestamps = new HashMap<>();
+    // Cooldowns
+    private final Map<UUID, Long> cooldowns = new HashMap<>();
+    // Warmup tasks
+    private final Map<UUID, Integer> warmupTasks = new HashMap<>();
+    // Saved "before teleport" locations (for /back)
+    private final Map<UUID, TeleportLocation> pendingBackLocations = new HashMap<>();
+
+    public TeleportManager(TeleportSuite plugin) { this.plugin = plugin; }
+
+    public void teleport(Player player, TeleportLocation destination) {
+        teleport(player, destination, true);
+    }
+
+    public void teleport(Player player, TeleportLocation destination, boolean saveBack) {
+        int delay = plugin.getConfigManager().getTeleportDelay();
+        if (player.hasPermission("teleportsuite.nodelay")) delay = 0;
+
+        // Check cooldown
+        if (!player.hasPermission("teleportsuite.nocooldown")) {
+            long cooldownMs = plugin.getConfigManager().getTeleportCooldown() * 1000L;
+            long lastTp = cooldowns.getOrDefault(player.getUniqueId(), 0L);
+            if (System.currentTimeMillis() - lastTp < cooldownMs) {
+                long remaining = (cooldownMs - (System.currentTimeMillis() - lastTp)) / 1000;
+                player.sendMessage(plugin.getConfigManager().getMessage("teleport-cooldown", "seconds", String.valueOf(remaining)));
+                return;
+            }
+        }
+
+        if (saveBack) pendingBackLocations.put(player.getUniqueId(), new TeleportLocation(player.getLocation(), plugin.getConfigManager().getServerName()));
+
+        if (delay <= 0) {
+            executeTeleport(player, destination);
+            return;
+        }
+
+        player.sendMessage(plugin.getConfigManager().getMessage("teleport-warmup", "seconds", String.valueOf(delay)));
+        Location startLoc = player.getLocation().clone();
+
+        int taskId = Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, () -> {
+            if (plugin.getConfigManager().cancelOnMove()) {
+                Location now = player.getLocation();
+                if (Math.abs(now.getX()-startLoc.getX()) > 0.5 || Math.abs(now.getZ()-startLoc.getZ()) > 0.5) {
+                    player.sendMessage(plugin.getConfigManager().getMessage("teleport-cancelled"));
+                    warmupTasks.remove(player.getUniqueId());
+                    return;
+                }
+            }
+            executeTeleport(player, destination);
+            warmupTasks.remove(player.getUniqueId());
+        }, delay * 20L);
+
+        warmupTasks.put(player.getUniqueId(), taskId);
+    }
+
+    private void executeTeleport(Player player, TeleportLocation dest) {
+        String localServer = plugin.getConfigManager().getServerName();
+
+        if (!dest.isLocalServer(localServer)) {
+            // BungeeCord-Teleport
+            if (plugin.getBungeeMessenger() != null) {
+                plugin.getBungeeMessenger().connectToServer(player, dest.getServer(), dest.getWorld(),
+                        dest.getX(), dest.getY(), dest.getZ(), dest.getYaw(), dest.getPitch());
+                player.sendMessage(plugin.getConfigManager().getMessage("teleport-success"));
+            }
+            return;
+        }
+
+        Location loc = dest.toBukkitLocation();
+        if (loc == null || loc.getWorld() == null) {
+            player.sendMessage("§cZielwelt nicht gefunden!");
+            return;
+        }
+
+        // Save last location to database
+        plugin.getDatabaseManager().saveLastLocation(player.getUniqueId(),
+                new TeleportLocation(player.getLocation(), localServer));
+
+        player.teleport(loc);
+        cooldowns.put(player.getUniqueId(), System.currentTimeMillis());
+        player.sendMessage(plugin.getConfigManager().getMessage("teleport-success"));
+    }
+
+    public void cancelWarmup(UUID uuid) {
+        Integer taskId = warmupTasks.remove(uuid);
+        if (taskId != null) Bukkit.getScheduler().cancelTask(taskId);
+    }
+
+    public TeleportLocation getBackLocation(UUID uuid) {
+        return pendingBackLocations.get(uuid);
+    }
+
+    // TPA
+    public void sendTpaRequest(Player from, Player to) {
+        tpaRequests.put(from.getUniqueId(), to.getUniqueId());
+        requestTimestamps.put(from.getUniqueId(), System.currentTimeMillis());
+
+        to.sendMessage(plugin.getConfigManager().getMessage("tpa-received", "player", from.getName()));
+        from.sendMessage(plugin.getConfigManager().getMessage("tpa-sent", "player", to.getName()));
+
+        int timeout = plugin.getConfigManager().getRequestTimeout();
+        Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, () -> {
+            if (tpaRequests.containsKey(from.getUniqueId())) {
+                tpaRequests.remove(from.getUniqueId());
+                requestTimestamps.remove(from.getUniqueId());
+                if (from.isOnline()) from.sendMessage(plugin.getConfigManager().getMessage("tpa-expired"));
+            }
+        }, timeout * 20L);
+    }
+
+    public boolean acceptTpa(Player target) {
+        UUID requester = null;
+        for (Map.Entry<UUID, UUID> entry : tpaRequests.entrySet()) {
+            if (entry.getValue().equals(target.getUniqueId())) {
+                requester = entry.getKey();
+                break;
+            }
+        }
+        if (requester == null) return false;
+
+        Player from = Bukkit.getPlayer(requester);
+        tpaRequests.remove(requester);
+        requestTimestamps.remove(requester);
+
+        if (from != null && from.isOnline()) {
+            from.sendMessage(plugin.getConfigManager().getMessage("tpa-accepted", "player", target.getName()));
+            teleport(from, new TeleportLocation(target.getLocation(), plugin.getConfigManager().getServerName()));
+        }
+        return true;
+    }
+
+    public boolean denyTpa(Player target) {
+        UUID requester = null;
+        for (Map.Entry<UUID, UUID> entry : tpaRequests.entrySet()) {
+            if (entry.getValue().equals(target.getUniqueId())) {
+                requester = entry.getKey();
+                break;
+            }
+        }
+        if (requester == null) return false;
+
+        Player from = Bukkit.getPlayer(requester);
+        tpaRequests.remove(requester);
+        requestTimestamps.remove(requester);
+
+        if (from != null && from.isOnline())
+            from.sendMessage(plugin.getConfigManager().getMessage("tpa-denied", "player", target.getName()));
+        return true;
+    }
+}

src/main/java/de/teleportsuite/managers/WarpManager.java

@@ -0,0 +1,39 @@
+package de.teleportsuite.managers;
+
+import de.teleportsuite.TeleportSuite;
+import de.teleportsuite.models.TeleportLocation;
+import de.teleportsuite.models.Warp;
+import org.bukkit.entity.Player;
+import java.util.List;
+
+public class WarpManager {
+    private final TeleportSuite plugin;
+    public WarpManager(TeleportSuite plugin) { this.plugin = plugin; }
+
+    public void setWarp(Player player, String name, String permission) {
+        TeleportLocation loc = new TeleportLocation(player.getLocation(), plugin.getConfigManager().getServerName());
+        plugin.getDatabaseManager().saveWarp(name, loc, player.getUniqueId(), permission);
+        player.sendMessage(plugin.getConfigManager().getMessage("warp-set", "name", name));
+    }
+
+    public void teleportWarp(Player player, String name) {
+        Warp warp = plugin.getDatabaseManager().getWarp(name);
+        if (warp == null) {
+            player.sendMessage(plugin.getConfigManager().getMessage("warp-not-found", "name", name));
+            return;
+        }
+        if (warp.getPermission() != null && !player.hasPermission(warp.getPermission())) {
+            player.sendMessage(plugin.getConfigManager().getMessage("no-permission"));
+            return;
+        }
+        plugin.getTeleportManager().teleport(player, warp.getLocation());
+    }
+
+    public boolean deleteWarp(String name) {
+        return plugin.getDatabaseManager().deleteWarp(name);
+    }
+
+    public List<Warp> getAllWarps() {
+        return plugin.getDatabaseManager().getAllWarps();
+    }
+}