- Island List

- Regiony skoro hotové

pom.xml

@@ -82,11 +82,16 @@
             <resource>
                 <directory>src/main/resources</directory>
                 <filtering>true</filtering>
+              
             </resource>
         </resources>
     </build>
 
     <repositories>
+        <repository>
+            <id>codemc-releases</id>
+            <url>https://repo.codemc.io/repository/maven-releases/</url>
+        </repository>
         <repository>
             <id>is-releases</id>
             <url>https://repo.infernalsuite.com/repository/maven-releases/</url>
@@ -103,6 +108,8 @@
             <id>jitpack.io</id>
             <url>https://jitpack.io</url>
         </repository>
+
+
     </repositories>
 
     <dependencies>
@@ -143,5 +150,11 @@
             <artifactId>MatrixColorAPI</artifactId>
             <version>v1.0.7</version>
         </dependency>
+        <dependency>
+            <groupId>com.github.retrooper</groupId>
+            <artifactId>packetevents-spigot</artifactId>
+            <version>2.11.2</version>
+            <scope>provided</scope>
+        </dependency>
     </dependencies>
 </project>

src/main/java/xyz/soukup/ecoCraftCore/EcoCraftCore.java

@@ -1,24 +1,36 @@
 package xyz.soukup.ecoCraftCore;
 
+import com.github.retrooper.packetevents.event.EventManager;
+import com.github.retrooper.packetevents.event.PacketListenerPriority;
+import com.infernalsuite.asp.api.AdvancedSlimePaperAPI;
+import com.infernalsuite.asp.api.world.SlimeWorldInstance;
 import com.j256.ormlite.dao.DaoManager;
 import com.j256.ormlite.jdbc.JdbcConnectionSource;
+import com.j256.ormlite.stmt.UpdateBuilder;
 import com.j256.ormlite.support.ConnectionSource;
 import com.j256.ormlite.table.TableUtils;
+import io.github.retrooper.packetevents.factory.spigot.SpigotPacketEventsBuilder;
 import io.papermc.paper.plugin.lifecycle.event.LifecycleEventManager;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.metadata.FixedMetadataValue;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.PluginManager;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.jetbrains.annotations.NotNull;
+import xyz.soukup.ecoCraftCore.database.objects.*;
+import xyz.soukup.ecoCraftCore.islands.IslandAdminCommand;
+import xyz.soukup.ecoCraftCore.islands.IslandSelectorCommand;
 import xyz.soukup.ecoCraftCore.money.MoneyCommand;
+import xyz.soukup.ecoCraftCore.player.OnKill;
 import xyz.soukup.ecoCraftCore.player.PreparePlayer;
-import xyz.soukup.ecoCraftCore.positionMarker.RulerCommand;
+import xyz.soukup.ecoCraftCore.player.TeleportRequestsHandler;
+import xyz.soukup.ecoCraftCore.positionMarker.MarkerCommand;
 import xyz.soukup.ecoCraftCore.shop.ShopCommand;
-import xyz.soukup.ecoCraftCore.database.objects.Account;
-import xyz.soukup.ecoCraftCore.database.objects.Shop;
-import xyz.soukup.ecoCraftCore.database.objects.Transaction;
 import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents;
 import xyz.soukup.ecoCraftCore.inventory.VirtualChest;
-import xyz.soukup.ecoCraftCore.positionMarker.RulerMarking;
+import xyz.soukup.ecoCraftCore.positionMarker.MarkerEvent;
 import xyz.soukup.ecoCraftCore.database.DaoRegistry;
 import xyz.soukup.ecoCraftCore.messages.Messages;
 import xyz.soukup.ecoCraftCore.shop.ShopLogic;
@@ -29,26 +41,41 @@ import java.sql.SQLException;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import com.github.retrooper.packetevents.PacketEvents;
 
+import xyz.soukup.ecoCraftCore.islands.ChunkModifier;
 
 public final class EcoCraftCore extends JavaPlugin {
 
     public static EcoCraftCore plugin;
     public static ConnectionSource connectionSource;
+    public static FileConfiguration config;
 
     @Override
     public void onEnable() {
+
         this.getLogger().info("plugin starting out");
+
         plugin = this;
 
+        config = getConfig();
+
+
+        this.getServer().getMessenger().registerOutgoingPluginChannel(this, "BungeeCord");
+
+        PacketEvents.setAPI(SpigotPacketEventsBuilder.build(this));
+        PacketEvents.getAPI().load();
+        PacketEvents.getAPI().init();
+
         try {
+            plugin.saveConfig();
+            saveIslandTemplates();
             Messages.init();
             prepareDatabase();
             registerCommands();
             registerEvents();
-        } catch (SQLException e) {
+            prepareSlimeWorldsSaver();
-            e.printStackTrace();
+
-            getLogger().severe("Failed to initialize database.");
         }catch (IOException e) {
             throw new RuntimeException(e);
         }
@@ -62,54 +89,177 @@ public final class EcoCraftCore extends JavaPlugin {
     @Override
     public void onDisable() {
 
+        plugin.saveConfig();
         VirtualChest.saveCache();
+        saveSlimeWorlds();
+        adiosDatabase();
 
+        PacketEvents.getAPI().terminate();
+
+    }
+
+    private void prepareSlimeWorldsSaver(){
+        Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, () -> {
+            AdvancedSlimePaperAPI asp = AdvancedSlimePaperAPI.instance();
+
+            for (SlimeWorldInstance slimeWorldInstance : asp.getLoadedWorlds()){
                 try {
-            if (connectionSource != null) {
+                    asp.saveWorld(slimeWorldInstance);
-                connectionSource.close();
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
                 }
-        } catch (Exception e) {
-            e.printStackTrace();
             }
+        }, 12000L, 12000L);
     }
 
-    private void prepareDatabase() throws SQLException {
+    private void prepareWorldInactivityUnloader(){
-        String databaseUrl = "jdbc:mysql://localhost:3306/ecc";
+        Bukkit.getScheduler().runTaskTimer(plugin, () -> {
-        connectionSource = new JdbcConnectionSource(databaseUrl, "ecc", "ecc");
+
-        Logger.getLogger("com.j256.ormlite.table.TableUtils").setLevel(Level.OFF);
+            long timeoutMillis = 30 * 60 * 1000;
+            long now = System.currentTimeMillis();
 
+            AdvancedSlimePaperAPI asp = AdvancedSlimePaperAPI.instance();
+            for (SlimeWorldInstance slimeWorldInstance : asp.getLoadedWorlds()) {
 
+                World world = slimeWorldInstance.getBukkitWorld();
+
+                if (!world.getPlayers().isEmpty()){
+                    world.removeMetadata("last_empty_time", plugin);
+                    continue;
+                }
+
+                if (!world.hasMetadata("last_empty_time")) {
+                    world.setMetadata("last_empty_time", new FixedMetadataValue(plugin, now));
+                    continue;
+                }
+
+                long emptySince = world.getMetadata("last_empty_time").get(0).asLong();
+
+
+                if ((now - emptySince) >= timeoutMillis) {
+                    Bukkit.unloadWorld(world, true);
+                }
+
+
+
+            }
+
+        }, 1200L, 1200L);
+
+    }
+
+    private void saveSlimeWorlds(){
+        AdvancedSlimePaperAPI asp = AdvancedSlimePaperAPI.instance();
+
+        for (SlimeWorldInstance slimeWorldInstance : asp.getLoadedWorlds()){
+            try {
+                asp.saveWorld(slimeWorldInstance);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        try {
+            UpdateBuilder<Island, Integer> updateBuilder = DaoRegistry.getIslandDao().updateBuilder();
+            updateBuilder.where().eq("active_on", config.getString("server.name"));
+            updateBuilder.updateColumnValue("active_on", "");
+            updateBuilder.update();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private void saveIslandTemplates(){
+        plugin.saveResource("island_templates/flat_grass.slime", false);
+        plugin.saveResource("island_templates/flat_sand.slime", false);
+        plugin.saveResource("island_templates/flat_hell.slime", false);
+
+
+    }
+
+    private void prepareDatabase() {
+
+        try {
+            String databaseHost = config.getString("database.host");
+            String databasePort = config.getString("database.port");
+            String databaseName = config.getString("database.database");
+            String databaseUsername = config.getString("database.user");
+            String databasePassword = config.getString("database.password");
+
+            String databaseUrl = "jdbc:mysql://" + databaseHost + ":" + databasePort + "/" + databaseName;
+            connectionSource = new JdbcConnectionSource(databaseUrl, databaseUsername, databasePassword);
+            Logger.getLogger("com.j256.ormlite.table.TableUtils").setLevel(Level.OFF);
+
+            TableUtils.createTableIfNotExists(connectionSource, ActiveServer.class);
             TableUtils.createTableIfNotExists(connectionSource, Transaction.class);
             TableUtils.createTableIfNotExists(connectionSource, Shop.class);
             TableUtils.createTableIfNotExists(connectionSource, VirtualChest.class);
             TableUtils.createTableIfNotExists(connectionSource, Account.class);
+            TableUtils.createTableIfNotExists(connectionSource, Island.class);
+            TableUtils.createTableIfNotExists(connectionSource, TeleportRequest.class);
+            TableUtils.createTableIfNotExists(connectionSource, Region.class);
+            TableUtils.createTableIfNotExists(connectionSource, RegionMember.class);
 
+            DaoRegistry.setActiveServerDao(DaoManager.createDao(connectionSource, ActiveServer.class));
             DaoRegistry.setTransactionDao(DaoManager.createDao(connectionSource, Transaction.class));
+            DaoRegistry.setIslandDaoo(DaoManager.createDao(connectionSource, Island.class));
             DaoRegistry.setShopDao(DaoManager.createDao(connectionSource, Shop.class));
             DaoRegistry.setVirtualChestDao(DaoManager.createDao(connectionSource, VirtualChest.class));
             DaoRegistry.setAccountDao(DaoManager.createDao(connectionSource, Account.class));
+            DaoRegistry.setTeleportRequestsDao(DaoManager.createDao(connectionSource, TeleportRequest.class));
+            DaoRegistry.setRegionDao(DaoManager.createDao(connectionSource, Region.class));
+            DaoRegistry.setRegionMemberDao(DaoManager.createDao(connectionSource, RegionMember.class));
+
+
+            ActiveServer activeServer = new ActiveServer(config.getString("server.name"));
+            activeServer.save();
+        } catch (SQLException e) {
+                e.printStackTrace();
 
         }
 
+
+
+    }
+
+    private void adiosDatabase(){
+
+
+        try {
+            ActiveServer activeServer = new ActiveServer(config.getString("server.name"));
+            activeServer.delete();
+
+            if (connectionSource != null) {
+                connectionSource.close();
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
     private void registerCommands() {
         @NotNull LifecycleEventManager<@NotNull Plugin> lm = this.getLifecycleManager();
 
-        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(ShopCommand.createCommand().build()));
+        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(ShopCommand.getCommand().build()));
-        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(RulerCommand.createCommand().build()));
+        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(MarkerCommand.getCommand().build()));
-        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(MoneyCommand.createCommand().build()));
+        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(MoneyCommand.getCommand().build()));
+        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(IslandAdminCommand.getCommand().build()));
+        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(IslandSelectorCommand.getCommand().build()));
     }
 
     private void registerEvents(){
         PluginManager pm = this.getServer().getPluginManager();
 
-        pm.registerEvents(new RulerMarking(), this);
+        pm.registerEvents(new TeleportRequestsHandler(), this);
+        pm.registerEvents(new OnKill(), this);
+        pm.registerEvents(new MarkerEvent(), this);
         pm.registerEvents(new VirtualChestLogic(), this);
         pm.registerEvents(new ShopLogic(), this);
         pm.registerEvents(new PreparePlayer(), this);
 
-    }
-
-
 
+        EventManager events = PacketEvents.getAPI().getEventManager();
+        events.registerListener(new ChunkModifier(this), PacketListenerPriority.NORMAL);
 
     }
+}

src/main/java/xyz/soukup/ecoCraftCore/database/DaoRegistry.java

@@ -10,7 +10,42 @@ public class    DaoRegistry {
     private static Dao<VirtualChest, Integer> virtualChestDao;
     private static Dao<Account, Integer> accountDao;
     private static Dao<Island, Integer> islandDao;
+    private static Dao<TeleportRequest, Integer> teleportRequestsDao;
+    private static Dao<ActiveServer, Integer> activeServerDao;
+    private static Dao<Region, Integer> regionDao;
+    private static Dao<RegionMember, Integer> regionMemberDao;
 
+    public static Dao<RegionMember, Integer> getRegionMemberDao() {
+        return regionMemberDao;
+    }
+
+    public static void setRegionMemberDao(Dao<RegionMember, Integer> regionMemberDao) {
+        DaoRegistry.regionMemberDao = regionMemberDao;
+    }
+
+    public static Dao<Region, Integer> getRegionDao() {
+        return regionDao;
+    }
+
+    public static void setRegionDao(Dao<Region, Integer> regionDao) {
+        DaoRegistry.regionDao = regionDao;
+    }
+
+    public static Dao<TeleportRequest, Integer> getTeleportRequestsDao() {
+        return teleportRequestsDao;
+    }
+
+    public static void setTeleportRequestsDao(Dao<TeleportRequest, Integer> teleportRequestsDao) {
+        DaoRegistry.teleportRequestsDao = teleportRequestsDao;
+    }
+
+    public static Dao<ActiveServer, Integer> getActiveServerDao() {
+        return activeServerDao;
+    }
+
+    public static void setActiveServerDao(Dao<ActiveServer, Integer> activeServerDao) {
+        DaoRegistry.activeServerDao = activeServerDao;
+    }
 
     public static Dao<Shop, Integer> getShopDao() {
         return shopDao;

src/main/java/xyz/soukup/ecoCraftCore/database/objects/ActiveServer.java

@@ -0,0 +1,34 @@
+package xyz.soukup.ecoCraftCore.database.objects;
+
+
+import com.j256.ormlite.field.DatabaseField;
+import com.j256.ormlite.table.DatabaseTable;
+import xyz.soukup.ecoCraftCore.database.DaoRegistry;
+
+import java.sql.SQLException;
+
+@DatabaseTable(tableName = "active_servers")
+public class ActiveServer {
+    @DatabaseField(unique = true, id = true)
+    private String name;
+
+    public ActiveServer(){
+
+    }
+
+    public ActiveServer(String name){
+        this.name = name;
+    }
+
+    public void save() throws SQLException {
+        DaoRegistry.getActiveServerDao().createIfNotExists(this);
+    }
+
+    public void delete() throws SQLException {
+        DaoRegistry.getActiveServerDao().delete(this);
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/database/objects/Island.java

@@ -15,9 +15,8 @@ public class Island {
     @DatabaseField(canBeNull = false, unique = true)
     private String uuid;
 
-    @DatabaseField(canBeNull = false, unique = true)
+    @DatabaseField(canBeNull = false)
-    private String name;
+    private String type;
-
 
     @DatabaseField(columnName = "display_name")
     private String displayName;
@@ -28,21 +27,26 @@ public class Island {
     @DatabaseField(canBeNull = false)
     private String owner;
 
-    @DatabaseField(canBeNull = false)
+    @DatabaseField(columnName = "owner_type", canBeNull = false)
     private String ownerType;
 
     @DatabaseField(canBeNull = false, dataType = DataType.BYTE_ARRAY, columnDefinition = "LONGBLOB")
     private byte[] data;
 
+    @DatabaseField(columnName = "is_public", canBeNull = false, defaultValue = "false")
+    private Boolean isPublic;
+
     @DatabaseField(defaultValue = "", columnName = "active_on")
     private String activeOn;
 
+
+
     public Island(){
 
     }
 
-    public Island(String name, String uuid, String displayName, String descritpion, String owner, String ownerType, byte[] data) {
+    public Island(String type, String uuid, String displayName, String descritpion, String owner, String ownerType, byte[] data) {
-        this.name = name;
+        this.type = type;
         this.uuid = uuid;
         this.displayName = displayName;
         this.descritpion = descritpion;
@@ -52,6 +56,13 @@ public class Island {
 
     }
 
+    public Boolean getPublic() {
+        return isPublic;
+    }
+    public void setPublic(Boolean isPublic) {
+        this.isPublic = isPublic;
+    }
+
     public void setData(byte[] data) {
         this.data = data;
     }
@@ -60,8 +71,8 @@ public class Island {
         return id;
     }
 
-    public String getName() {
+    public String getType() {
-        return name;
+        return type;
     }
 
     public String getDisplayName() {

src/main/java/xyz/soukup/ecoCraftCore/database/objects/Region.java

@@ -0,0 +1,165 @@
+package xyz.soukup.ecoCraftCore.database.objects;
+
+import com.j256.ormlite.dao.ForeignCollection;
+import com.j256.ormlite.field.DatabaseField;
+import com.j256.ormlite.field.ForeignCollectionField;
+import com.j256.ormlite.table.DatabaseTable;
+import xyz.soukup.ecoCraftCore.database.DaoRegistry;
+
+import java.util.HashMap;
+import java.util.List;
+
+@DatabaseTable(tableName = "regions")
+public class Region {
+
+    public static final HashMap<String, List<Region>> cache = new HashMap<>();
+
+    @DatabaseField(generatedId = true)
+    private int id;
+
+    @DatabaseField(canBeNull = false)
+    private String island;
+
+    @DatabaseField(columnName = "region_type", canBeNull = false)
+    private int regionType;
+
+    @DatabaseField(canBeNull = false)
+    private int x1;
+
+    @DatabaseField(canBeNull = false)
+    private int y1;
+
+    @DatabaseField(canBeNull = false)
+    private int x2;
+
+    @DatabaseField(canBeNull = false)
+    private int y2;
+
+    @ForeignCollectionField(eager = true)
+    private ForeignCollection<RegionMember> regionMembers;
+
+    @DatabaseField()
+    private Integer value;
+
+    public Region() {
+
+    }
+
+    public Region(String island, int regionType, int x1, int y1, int x2, int y2) {
+        this.island = island;
+        this.regionType = regionType;
+        this.x1 = Math.min(x1, x2);
+        this.y1 = Math.min(y1, y2);
+        this.x2 = Math.max(x1, x2) ;
+        this.y2 = Math.max(y1, y2);
+
+    }
+
+    public int getRegionType() {
+        return regionType;
+    }
+
+    public int getX1() {
+        return x1;
+    }
+
+    public int getY1() {
+        return y1;
+    }
+
+    public int getX2() {
+        return x2;
+    }
+
+    public int getY2() {
+        return y2;
+    }
+
+    public ForeignCollection<RegionMember> getRegionMembers() {
+        return regionMembers;
+    }
+
+    public Integer getValue() {
+        return value;
+    }
+
+    public String getIsland() {
+        return island;
+    }
+
+
+
+
+
+    public void setRegionType(int regionType) {
+        this.regionType = regionType;
+    }
+
+    public void setValue(Integer value) {
+        this.value = value;
+    }
+    
+    public void save(){
+        try {
+            DaoRegistry.getRegionDao().createOrUpdate(this);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void addRegionMember(String memberType, String member, String membershipType){
+        RegionMember regionMember = new RegionMember(this, memberType, member, membershipType);
+        regionMember.save();
+    }
+
+    public boolean isInside(int x, int y) {
+        return x >= this.x1 && x <= this.x2 && y >= this.y1 && y <= this.y2;
+    }
+    
+    public static Region findById(int id) {
+        try {
+            return DaoRegistry.getRegionDao().queryForId(id);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    public static void cacheRegions(String island) {
+        try {
+            List<Region> regions = DaoRegistry.getRegionDao().queryBuilder()
+                    .where()
+                    .eq("island", island)
+                    .query();
+            cache.put(island, regions);
+        } catch (Exception e) {
+
+        }
+    }
+
+    public static Region findRegion(int x, int y, String island) {
+
+        Region region = null;
+        int highestType = -1;
+
+        if (!cache.containsKey(island)) {
+            cacheRegions(island);
+        }
+
+        for (Region cachedRegion : cache.get(island)) {
+            if (!cachedRegion.isInside(x, y)) {
+                continue;
+            }
+            if (highestType >= cachedRegion.getRegionType()){
+                continue;
+            }
+            region = cachedRegion;
+        }
+
+        return region;
+
+
+    }
+
+
+}
+

src/main/java/xyz/soukup/ecoCraftCore/database/objects/RegionMember.java

@@ -0,0 +1,65 @@
+package xyz.soukup.ecoCraftCore.database.objects;
+
+import com.j256.ormlite.field.DatabaseField;
+import com.j256.ormlite.table.DatabaseTable;
+import xyz.soukup.ecoCraftCore.database.DaoRegistry;
+
+import java.sql.SQLException;
+
+@DatabaseTable(tableName = "region_members")
+public class RegionMember {
+
+    @DatabaseField(generatedId = true)
+    private int id;
+
+    @DatabaseField(foreign = true, foreignAutoRefresh = true)
+    private Region region;
+
+    @DatabaseField(columnName = "member_type", canBeNull = false)
+    private String membertype;
+
+    @DatabaseField(columnName = "member_name", canBeNull = false)
+    private String memberName;
+
+    @DatabaseField(columnName = "membership_type", canBeNull = false)
+    private String membershipType;
+
+    public RegionMember(){
+
+    }
+
+    public RegionMember(Region region, String membertype, String memberName, String membershipType){
+        this.region = region;
+        this.membertype = membertype;
+        this.memberName = memberName;
+        this.membershipType = membershipType;
+    }
+
+    public Region getRegion() {
+        return region;
+    }
+
+    public String getMembertype() {
+        return membertype;
+    }
+
+    public String getName() {
+        return memberName;
+    }
+
+    public String getMembershipType() {
+        return membershipType;
+    }
+
+    public void setMembershipType(String membershipType) {
+        this.membershipType = membershipType;
+    }
+
+    public void save(){
+        try {
+            DaoRegistry.getRegionMemberDao().createOrUpdate(this);
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/database/objects/TeleportRequest.java

@@ -0,0 +1,96 @@
+package xyz.soukup.ecoCraftCore.database.objects;
+
+import com.j256.ormlite.field.DatabaseField;
+import com.j256.ormlite.table.DatabaseTable;
+import org.bukkit.Location;
+import xyz.soukup.ecoCraftCore.database.DaoRegistry;
+
+import java.sql.SQLException;
+
+@DatabaseTable(tableName = "teleport_requests")
+public class TeleportRequest {
+
+    @DatabaseField(unique = true, id = true)
+    private String player;
+
+    @DatabaseField(canBeNull = false)
+    private String server;
+
+    @DatabaseField(canBeNull = false)
+    private String world;
+
+    @DatabaseField
+    private Integer x;
+
+    @DatabaseField
+    private Integer y;
+
+    @DatabaseField
+    private Integer z;
+
+    @DatabaseField
+    private Float yaw;
+
+    @DatabaseField
+    private Float pitch;
+
+    public TeleportRequest() {
+    }
+
+    public TeleportRequest(String player, String server, String world) {
+        this.player = player;
+        this.server = server;
+        this.world = world;
+    }
+
+    public TeleportRequest(String player, String server, String world, Integer x, Integer y, Integer z, Float yaw, Float pitch) {
+        this.player = player;
+        this.server = server;
+        this.world = world;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.yaw = yaw;
+        this.pitch = pitch;
+    }
+
+    public String getServer() {
+        return server;
+    }
+
+    public String getWorld() {
+        return world;
+    }
+
+    public String getPlayer() {
+        return player;
+    }
+
+    public Integer getX() {
+        return x;
+    }
+
+    public Integer getY() {
+        return y;
+    }
+
+    public Integer getZ() {
+        return z;
+    }
+
+    public Float getYaw() {
+        return yaw;
+    }
+
+    public Float getPitch() {
+        return pitch;
+    }
+
+    public void save() throws SQLException {
+        DaoRegistry.getTeleportRequestsDao().createOrUpdate(this);
+    }
+
+    public void delete() throws SQLException {
+        DaoRegistry.getTeleportRequestsDao().delete(this);
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/gui/GuiItemBuilder.java

@@ -2,16 +2,19 @@ package xyz.soukup.ecoCraftCore.gui;
 
 import com.github.stefvanschie.inventoryframework.gui.GuiItem;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import org.bukkit.Material;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
 
+import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
+import java.util.stream.Collectors;
 
 public class GuiItemBuilder {
-    private ItemStack itemStack;
+    private final ItemStack itemStack;
-    private ItemMeta itemMeta;
+    private final ItemMeta itemMeta;
 
     public GuiItemBuilder(Material material){
         this.itemStack = new ItemStack(material);
@@ -30,6 +33,14 @@ public class GuiItemBuilder {
         return this;
     }
 
+    public GuiItemBuilder setRawLore(String rawLore){
+        List<Component> lore = Arrays.stream(rawLore.split("\\R"))
+                .map(line -> MiniMessage.miniMessage().deserialize(line))
+                .collect(Collectors.toList());
+        itemMeta.lore(lore);
+        return this;
+    }
+
     public GuiItem build(){
         this.itemStack.setItemMeta(this.itemMeta);
         return new GuiItem(this.itemStack);

src/main/java/xyz/soukup/ecoCraftCore/islands/ChunkModifier.java

@@ -0,0 +1,257 @@
+package xyz.soukup.ecoCraftCore.islands;
+
+import com.github.retrooper.packetevents.event.PacketListener;
+import com.github.retrooper.packetevents.event.PacketSendEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.world.chunk.BaseChunk;
+import com.github.retrooper.packetevents.protocol.world.chunk.Column;
+import com.github.retrooper.packetevents.protocol.world.chunk.LightData;
+import com.github.retrooper.packetevents.protocol.world.chunk.TileEntity;
+import com.github.retrooper.packetevents.protocol.world.chunk.impl.v_1_18.Chunk_v1_18;
+import com.github.retrooper.packetevents.protocol.world.chunk.palette.DataPalette;
+import com.github.retrooper.packetevents.protocol.world.chunk.palette.PaletteType;
+import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerChunkData;
+import org.bukkit.Bukkit;
+import org.bukkit.NamespacedKey;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.BitSet;
+import java.util.Arrays;
+import java.util.HashMap;
+
+public class ChunkModifier implements PacketListener {
+
+    private final JavaPlugin plugin;
+    private final NamespacedKey keyX1, keyX2, keyZ1, keyZ2, keyType;
+
+    HashMap<String, Integer> blockStates = new HashMap<>();
+
+    public ChunkModifier(JavaPlugin plugin) {
+        this.plugin = plugin;
+        this.keyX1 = new NamespacedKey(plugin, "borderx1");
+        this.keyX2 = new NamespacedKey(plugin, "borderx2");
+        this.keyZ1 = new NamespacedKey(plugin, "bordery1"); // Based on your spec
+        this.keyZ2 = new NamespacedKey(plugin, "borderx2"); // Based on your spec
+        this.keyType = new NamespacedKey(plugin, "island_type");
+    }
+
+    @Override
+    public void onPacketSend(PacketSendEvent event) {
+        if (event.getPacketType() != PacketType.Play.Server.CHUNK_DATA) return;
+
+        Player bukkitPlayer = Bukkit.getPlayer(event.getUser().getUUID());
+        if (bukkitPlayer == null) return;
+
+        World world = bukkitPlayer.getWorld();
+        PersistentDataContainer pdc = world.getPersistentDataContainer();
+
+        String type = pdc.get(keyType, PersistentDataType.STRING);
+        if (type == null) return;
+
+        String block;
+
+        switch (type){
+            case "flat_grass":
+            case "flat_sand":
+                block = "WATER";
+                break;
+            case "flat_hell":
+                block = "LAVA";
+                break;
+            default:
+                return;
+
+        }
+
+        Integer x1 = pdc.get(keyX1, PersistentDataType.INTEGER);
+        Integer x2 = pdc.get(keyX2, PersistentDataType.INTEGER);
+        Integer z1 = pdc.get(keyZ1, PersistentDataType.INTEGER);
+        Integer z2 = pdc.get(keyZ2, PersistentDataType.INTEGER);
+        if (x1 == null || x2 == null || z1 == null || z2 == null) return;
+
+        int minCX = Math.min(x1 >> 4, x2 >> 4) - 1;
+        int maxCX = Math.max(x1 >> 4, x2 >> 4) + 1;
+        int minCZ = Math.min(z1 >> 4, z2 >> 4) - 1;
+        int maxCZ = Math.max(z1 >> 4, z2 >> 4) + 1;
+
+        WrapperPlayServerChunkData wrapper = new WrapperPlayServerChunkData(event);
+
+        Column original = wrapper.getColumn();
+        if (original == null) return;
+
+        int chunkX = original.getX();
+        int chunkZ = original.getZ();
+        if (chunkX >= minCX && chunkX <= maxCX && chunkZ >= minCZ && chunkZ <= maxCZ) return;
+
+        Column ghostColumn = createGhostColumn(world, original, resolveBlockStateID(block));
+        if (ghostColumn == null) return;
+
+        wrapper.setColumn(ghostColumn);
+
+        wrapper.setLightData(buildFullBrightLightData(world));
+    }
+
+    private static LightData buildFullBrightLightData(World world) {
+        int sections = (world.getMaxHeight() - world.getMinHeight()) >> 4;
+        if (sections <= 0) sections = 24;
+
+        int lightCount = sections + 2;
+
+        byte[] fullSky = new byte[2048];
+        Arrays.fill(fullSky, (byte) 0xFF);
+
+        byte[] noBlock = new byte[2048];
+
+
+        boolean hasSkyLight = world.getEnvironment() != World.Environment.NETHER
+                && world.getEnvironment() != World.Environment.THE_END; // adjust if you have custom dims
+
+        BitSet skyMask = new BitSet(lightCount);
+        BitSet blockMask = new BitSet(lightCount);
+        BitSet emptySkyMask = new BitSet(lightCount);
+        BitSet emptyBlockMask = new BitSet(lightCount);
+
+        byte[][] skyArray;
+        int skyCount;
+        if (hasSkyLight) {
+            skyMask.set(0, lightCount);
+            skyCount = lightCount;
+            skyArray = new byte[skyCount][];
+            for (int i = 0; i < skyCount; i++) {
+                skyArray[i] = fullSky;
+            }
+        } else {
+            // no skylight dimension
+            emptySkyMask.set(0, lightCount);
+            skyCount = 0;
+            skyArray = new byte[0][];
+        }
+
+        blockMask.set(0, lightCount);
+        int blockCount = lightCount;
+        byte[][] blockArray = new byte[blockCount][];
+        for (int i = 0; i < blockCount; i++) {
+            blockArray[i] = noBlock;
+        }
+
+        LightData ld = new LightData();
+        ld.setTrustEdges(true);
+        ld.setSkyLightMask(skyMask);
+        ld.setBlockLightMask(blockMask);
+        ld.setEmptySkyLightMask(emptySkyMask);
+        ld.setEmptyBlockLightMask(emptyBlockMask);
+        ld.setSkyLightCount(skyCount);
+        ld.setBlockLightCount(blockCount);
+        ld.setSkyLightArray(skyArray);
+        ld.setBlockLightArray(blockArray);
+        return ld;
+    }
+
+    private Column createGhostColumn(World world, Column original, int blockID) {
+        int sections = (world.getMaxHeight() - world.getMinHeight()) >> 4;
+        if (sections <= 0) sections = 24;
+
+        BaseChunk[] originalChunks = original.getChunks();
+
+        // Find any existing biome palette from the original packet; we will reuse it.
+        DataPalette fallbackBiomePalette = null;
+        if (originalChunks != null) {
+            for (BaseChunk bc : originalChunks) {
+                if (bc instanceof Chunk_v1_18 c) {
+                    fallbackBiomePalette = c.getBiomeData();
+                    break;
+                }
+            }
+        }
+
+
+        BaseChunk[] chunks = new BaseChunk[sections];
+
+        for (int sectionIndex = 0; sectionIndex < sections; sectionIndex++) {
+            DataPalette biomePalette = fallbackBiomePalette;
+
+            if (originalChunks != null && sectionIndex < originalChunks.length && originalChunks[sectionIndex] instanceof Chunk_v1_18 c) {
+                // Prefer the matching section's biome palette if present
+                biomePalette = c.getBiomeData();
+            }
+
+            DataPalette blockPalette = PaletteType.CHUNK.create();
+
+            Chunk_v1_18 section = new Chunk_v1_18(0, blockPalette, biomePalette);
+            section.set(0, 0, 0, 0);
+
+            chunks[sectionIndex] = section;
+        }
+
+        if (chunks[0] instanceof Chunk_v1_18 section0) {
+            for (int localY = 0; localY <= 1; localY++) {
+                for (int x = 0; x < 16; x++) {
+                    for (int z = 0; z < 16; z++) {
+                        section0.set(x, localY, z, blockID);
+                    }
+                }
+            }
+        }
+
+        return new Column(
+                original.getX(),
+                original.getZ(),
+                true,
+                chunks,
+                new TileEntity[0],
+                original.getHeightMaps()
+        );
+    }
+
+    private int resolveBlockStateID(String name) {
+        Integer stateID = blockStates.get(name);
+        if (stateID != null) return stateID;
+
+        int resolved = 0;
+
+        try {
+            Object blockState = resolveNmsBlockState(name);
+            if (blockState != null) {
+                Integer id = tryGetBlockStateIdViaBlockGetId(blockState);
+                if (id != null && id > 0) {
+                    resolved = id;
+                }
+            }
+        } catch (ReflectiveOperationException ignored) {
+
+        }
+
+        blockStates.put(name, resolved);
+        return resolved;
+    }
+
+    private static Object resolveNmsBlockState(String name) throws ReflectiveOperationException {
+        Class<?> blocksClass = Class.forName("net.minecraft.world.level.block.Blocks");
+        Field waterField = blocksClass.getField(name);
+        Object waterBlock = waterField.get(null);
+
+        Method defaultBlockState = waterBlock.getClass().getMethod("defaultBlockState");
+        return defaultBlockState.invoke(waterBlock);
+    }
+
+    private static Integer tryGetBlockStateIdViaBlockGetId(Object blockState) throws ReflectiveOperationException {
+        // Block.getId(BlockState) exists on many modern versions
+        Class<?> blockClass = Class.forName("net.minecraft.world.level.block.Block");
+        Class<?> blockStateClass = Class.forName("net.minecraft.world.level.block.state.BlockState");
+
+        try {
+            Method getId = blockClass.getMethod("getId", blockStateClass);
+            Object idObj = getId.invoke(null, blockState);
+            return (idObj instanceof Integer i) ? i : null;
+        } catch (NoSuchMethodException ignored) {
+            return null;
+        }
+    }
+
+}

src/main/java/xyz/soukup/ecoCraftCore/islands/DatabaseIslandLoader.java

@@ -10,7 +10,7 @@ import java.sql.SQLException;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class IslandLoader implements SlimeLoader {
+public class DatabaseIslandLoader implements SlimeLoader {
 
 
     @Override
@@ -38,6 +38,8 @@ public class IslandLoader implements SlimeLoader {
                     .setCountOf(true)
                     .where()
                     .eq("uuid", worldName)
+                    .and()
+                    .isNotNull("data")
                     .countOf();
 
             return count > 0;

src/main/java/xyz/soukup/ecoCraftCore/islands/FileIslandLoader.java

@@ -0,0 +1,72 @@
+package xyz.soukup.ecoCraftCore.islands;
+
+import com.infernalsuite.asp.api.exceptions.UnknownWorldException;
+import com.infernalsuite.asp.api.loaders.SlimeLoader;
+import xyz.soukup.ecoCraftCore.EcoCraftCore;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class FileIslandLoader implements SlimeLoader {
+
+    private final Path storagePath;
+    private static final String EXTENSION = ".slime";
+
+    public FileIslandLoader() {
+        // Creates a directory named 'islands' inside your plugin folder
+        this.storagePath = EcoCraftCore.plugin.getDataFolder().toPath().resolve("island_templates");
+
+        if (!Files.exists(storagePath)) {
+            storagePath.toFile().mkdirs();
+        }
+    }
+
+    private Path getWorldPath(String worldName) {
+        return storagePath.resolve(worldName + EXTENSION);
+    }
+
+    @Override
+    public byte[] readWorld(String worldName) throws UnknownWorldException, IOException {
+        Path path = getWorldPath(worldName);
+        if (!Files.exists(path)) {
+            throw new UnknownWorldException(worldName);
+        }
+        return Files.readAllBytes(path);
+    }
+
+    @Override
+    public boolean worldExists(String worldName) throws IOException {
+        return Files.exists(getWorldPath(worldName));
+    }
+
+    @Override
+    public void saveWorld(String worldName, byte[] serializedWorld) throws IOException {
+        // Files.write will create or overwrite the file automatically
+        Files.write(getWorldPath(worldName), serializedWorld);
+    }
+
+    @Override
+    public void deleteWorld(String worldName) throws IOException {
+        Files.deleteIfExists(getWorldPath(worldName));
+    }
+
+    @Override
+    public List<String> listWorlds() throws IOException {
+        File folder = storagePath.toFile();
+        File[] files = folder.listFiles((dir, name) -> name.endsWith(EXTENSION));
+
+        if (files == null) {
+            return Collections.emptyList();
+        }
+
+        return Arrays.stream(files)
+                .map(file -> file.getName().replace(EXTENSION, ""))
+                .collect(Collectors.toList());
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/islands/IslandAdminCommand.java

@@ -0,0 +1,324 @@
+package xyz.soukup.ecoCraftCore.islands;
+
+import com.infernalsuite.asp.api.AdvancedSlimePaperAPI;
+import com.infernalsuite.asp.api.world.SlimeWorld;
+import com.j256.ormlite.stmt.QueryBuilder;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.context.CommandContext;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.command.brigadier.Commands;
+import org.bukkit.Location;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+import xyz.soukup.ecoCraftCore.database.DaoRegistry;
+import xyz.soukup.ecoCraftCore.database.objects.Island;
+import xyz.soukup.ecoCraftCore.messages.Messages;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.List;
+
+import static xyz.soukup.ecoCraftCore.EcoCraftCore.config;
+import static xyz.soukup.ecoCraftCore.EcoCraftCore.plugin;
+
+public class IslandAdminCommand {
+    private final AdvancedSlimePaperAPI asp = AdvancedSlimePaperAPI.instance();
+
+
+    public static LiteralArgumentBuilder<CommandSourceStack> getCommand() {
+
+
+        LiteralArgumentBuilder<CommandSourceStack> tp = Commands.literal("tp")
+                .then(Commands.argument("uuid", StringArgumentType.word())
+                        .executes(IslandAdminCommand::teleport)
+                        .suggests(((context, builder) -> {
+                            try {
+                                QueryBuilder<Island, Integer> queryBuilder = DaoRegistry.getIslandDao().queryBuilder();
+                                queryBuilder.selectColumns("uuid");
+                                List<Island> islands = queryBuilder.query();
+                                for (Island island : islands) {
+                                    builder.suggest(island.getUuid());
+                                }
+                                return builder.buildFuture();
+                            } catch (SQLException e) {
+                                throw new RuntimeException(e);
+                            }
+                        })));
+
+        LiteralArgumentBuilder<CommandSourceStack> create = Commands.literal("create")
+                .then(Commands.argument("type", StringArgumentType.word())
+                        .suggests(((context, builder) -> {
+                            try {
+                                IslandManager islandManager = new IslandManager();
+                                FileIslandLoader fileLoader = islandManager.fileLoader;
+                                for (String world: fileLoader.listWorlds()){
+                                    builder.suggest(world);
+                                }
+                            } catch (IOException e) {
+                                throw new RuntimeException(e);
+                            }
+                            return builder.buildFuture();
+                        }))
+                        .then(Commands.argument("display_name", StringArgumentType.string())
+                                .then(Commands.argument("description", StringArgumentType.greedyString())
+                                        .executes(IslandAdminCommand::createWorld))));
+
+        LiteralArgumentBuilder<CommandSourceStack> load = Commands.literal("load")
+                .then(Commands.argument("uuid", StringArgumentType.word())
+                        .suggests(((context, builder) -> {
+                            try {
+                                QueryBuilder<Island, Integer> queryBuilder = DaoRegistry.getIslandDao().queryBuilder();
+                                queryBuilder.selectColumns("uuid");
+                                List<Island> islands = queryBuilder.query();
+                                for (Island island : islands) {
+                                    builder.suggest(island.getUuid());
+                                }
+                                return builder.buildFuture();
+                            } catch (SQLException e) {
+                                throw new RuntimeException(e);
+                            }
+                        }))
+                        .executes(IslandAdminCommand::loadWorld));
+
+        LiteralArgumentBuilder<CommandSourceStack> loadTemplate = Commands.literal("loadTemplate")
+                .then(Commands.argument("name", StringArgumentType.word())
+                        .suggests(((context, builder) -> {
+                            IslandManager islandManager = new IslandManager();
+                            FileIslandLoader fileLoader = islandManager.fileLoader;
+
+                            try {
+                                for (String world: fileLoader.listWorlds()){
+                                    builder.suggest(world);
+                                }
+                            } catch (IOException e) {
+                                throw new RuntimeException(e);
+                            }
+                            return builder.buildFuture();
+                        }))
+                        .executes(IslandAdminCommand::loadTemplate));
+
+        LiteralArgumentBuilder<CommandSourceStack> template = Commands.literal("template")
+                .then(Commands.argument("uuid", StringArgumentType.word())
+                        .suggests((context, builder) -> {
+                            try {
+                                QueryBuilder<Island, Integer> queryBuilder = DaoRegistry.getIslandDao().queryBuilder();
+                                queryBuilder.selectColumns("uuid");
+                                List<Island> islands = queryBuilder.query();
+                                for (Island island : islands) {
+                                    builder.suggest(island.getUuid());
+                                }
+                                return builder.buildFuture();
+                            } catch (SQLException e) {
+                                throw new RuntimeException(e);
+                            }
+                        })
+                        .then(Commands.argument("templateName", StringArgumentType.word())
+                                .executes(IslandAdminCommand::createTemplate)));
+
+        LiteralArgumentBuilder<CommandSourceStack> metadata = Commands.literal("metadata")
+                .then(Commands.argument("key", StringArgumentType.word())
+                        .then(Commands.argument("value", IntegerArgumentType.integer())
+                                .executes(IslandAdminCommand::setMetadata)));
+
+        LiteralArgumentBuilder<CommandSourceStack> metadataString = Commands.literal("metadataString")
+                .then(Commands.argument("key", StringArgumentType.word())
+                        .then(Commands.argument("value", StringArgumentType.string())
+                                .executes(IslandAdminCommand::setMetadataString)));
+
+        LiteralArgumentBuilder<CommandSourceStack> expand = Commands.literal("expand")
+                .then(Commands.argument("lenght", IntegerArgumentType.integer())
+                        .executes(IslandAdminCommand::expandIsland));
+
+        LiteralArgumentBuilder<CommandSourceStack> listMetadata = Commands.literal("listMetadata")
+                .executes(IslandAdminCommand::readAllMetadata);
+
+        LiteralArgumentBuilder<CommandSourceStack> spawn = Commands.literal("spawn")
+                .executes(IslandAdminCommand::setSpawn);
+
+        LiteralArgumentBuilder<CommandSourceStack> enviroment = Commands.literal("environment")
+                .then(Commands.argument("environment", StringArgumentType.word())
+                        .executes(IslandAdminCommand::setEnvironment)
+                        .suggests(((context, builder) -> {
+                            builder.suggest("normal");
+                            builder.suggest("nether");
+                            builder.suggest("the_end");
+                            return builder.buildFuture();
+                        })));
+
+        LiteralArgumentBuilder<CommandSourceStack> setDefaultIsland = Commands.literal("setDefaultIsland")
+                .executes(IslandAdminCommand::setDefualtIsland);
+
+        return Commands.literal("island-admin")
+                .requires(commandSourceStack -> commandSourceStack.getSender().isOp())
+                .then(tp)
+                .then(create)
+                .then(load)
+                .then(template)
+                .then(metadata)
+                .then(metadataString)
+                .then(listMetadata)
+                .then(loadTemplate)
+                .then(spawn)
+                .then(enviroment)
+                .then(expand)
+                .then(setDefaultIsland);
+
+
+
+    }
+
+    private static int setDefualtIsland(CommandContext<CommandSourceStack> context){
+        if (!(context.getSource().getSender() instanceof Player player)) return 0;
+        String uuid = player.getWorld().getName();
+        config.set("islands.spawn", uuid);
+        plugin.saveConfig();
+        player.sendMessage("done.");
+        return 0;
+
+    }
+
+    private static int setSpawn(CommandContext<CommandSourceStack> context) {
+        if (!(context.getSource().getSender() instanceof Player player)) return 0;
+        IslandManager islandManager = new IslandManager();
+        Location spawn = player.getLocation();
+        String uuid = player.getWorld().getName();
+        islandManager.changeSpawn(spawn, uuid);
+        Messages.send(player, "island.setSpawn.success");
+
+        return 0;
+    }
+
+    private static int setEnvironment(CommandContext<CommandSourceStack> context) {
+        if (!(context.getSource().getSender() instanceof Player player)) return 0;
+        IslandManager islandManager = new IslandManager();
+        String uuid = player.getWorld().getName();
+        islandManager.changeEnviroment(context.getArgument("environment", String.class), uuid);
+        Messages.send(player, "island.setEnvironment.success");
+
+        return 0;
+    }
+
+
+    private static int teleport(CommandContext<CommandSourceStack> context) {
+        IslandManager islandManager = new IslandManager();
+        try {
+            Integer status = islandManager.teleport((Player) context.getSource().getSender(), context.getArgument("uuid", String.class));
+            context.getSource().getSender().sendMessage(String.valueOf(status));
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+        return 0;
+    }
+
+    private static int createWorld(CommandContext<CommandSourceStack> context) {
+        IslandManager islandManager = new IslandManager();
+        String type = context.getArgument("type", String.class);
+        String displayName = context.getArgument("display_name", String.class);
+        String description = context.getArgument("description", String.class);
+        String owner = context.getSource().getSender().getName();
+        String uuid = islandManager.createIsland(type, displayName, description, owner, "player");
+        context.getSource().getSender().sendMessage("Created island: " + uuid);
+
+        return 0;
+    }
+
+    private static int loadWorld(CommandContext<CommandSourceStack> context) {
+        IslandManager islandManager = new IslandManager();
+        islandManager.loadIsland(context.getArgument("uuid", String.class));
+        context.getSource().getSender().sendMessage("done.");
+        return 0;
+    }
+
+    private static int loadTemplate(CommandContext<CommandSourceStack> context) {
+        IslandManager islandManager = new IslandManager();
+        islandManager.loadIslandTemplate(context.getArgument("name", String.class));
+        context.getSource().getSender().sendMessage("done.");
+        return 0;
+    }
+
+    private static int createTemplate(CommandContext<CommandSourceStack> context) {
+        IslandManager islandManager = new IslandManager();
+        String uuid = StringArgumentType.getString(context, "uuid");
+        String templateName = StringArgumentType.getString(context, "templateName");
+        context.getSource().getSender().sendMessage("§aCreating template '" + templateName + "' from world '" + uuid + "'...");
+        islandManager.createIslandTemplate(uuid, templateName);
+        context.getSource().getSender().sendMessage("§aTemplate created successfully!");
+        return 1;
+    }
+
+    private static int setMetadata(CommandContext<CommandSourceStack> context) {
+        if (!(context.getSource().getSender() instanceof Player player)) return 0;
+
+        String keyName = StringArgumentType.getString(context, "key");
+        Integer value = IntegerArgumentType.getInteger(context, "value");
+
+        player.getWorld().getPersistentDataContainer().set(new NamespacedKey(plugin, keyName), PersistentDataType.INTEGER, value);
+        context.getSource().getSender().sendMessage(keyName + " set to " + value);
+        return 1;
+    }
+
+    private static int setMetadataString(CommandContext<CommandSourceStack> context) {
+        if (!(context.getSource().getSender() instanceof Player player)) return 0;
+
+        String keyName = StringArgumentType.getString(context, "key");
+        String value = StringArgumentType.getString(context, "value");
+
+        player.getWorld().getPersistentDataContainer().set(new NamespacedKey(plugin, keyName), PersistentDataType.STRING, value);
+        context.getSource().getSender().sendMessage(keyName + " set to " + value);
+
+        return 1;
+    }
+
+    private static int readAllMetadata(CommandContext<CommandSourceStack> context) {
+        if (!(context.getSource().getSender() instanceof Player player)) {
+            context.getSource().getSender().sendMessage("§cOnly players can use this.");
+            return 0;
+        }
+
+
+        PersistentDataContainer pdc = player.getWorld().getPersistentDataContainer();
+        if (pdc.getKeys().isEmpty()) {
+            player.sendMessage("§eNo metadata found.");
+            return 1;
+        }
+
+        player.sendMessage("§6--- World Metadata ---");
+        for (NamespacedKey key : pdc.getKeys()) {
+            String val = "unknown";
+            // Logic to determine type for display
+            if (pdc.has(key, PersistentDataType.STRING)) val = pdc.get(key, PersistentDataType.STRING);
+            else if (pdc.has(key, PersistentDataType.INTEGER)) val = String.valueOf(pdc.get(key, PersistentDataType.INTEGER));
+
+            player.sendMessage("§b" + key.getKey() + "§7: §f" + val);
+        }
+        return 1;
+    }
+
+    private static int expandIsland(CommandContext<CommandSourceStack> context){
+
+        Player player = (Player) context.getSource().getSender();
+        float yaw = player.getLocation().getYaw();
+        int lenght = IntegerArgumentType.getInteger(context, "lenght");
+        String uuid = player.getWorld().getName();
+
+        IslandManager islandManager = new IslandManager();
+        islandManager.expandIsland(yaw, lenght, uuid);
+
+
+        return 0;
+    }
+
+    private static void saveSlimeWorld(SlimeWorld world, Player player, String key, String val) {
+        try {
+            AdvancedSlimePaperAPI.instance().saveWorld(world);
+            player.sendMessage("§aMetadata set: §f" + key + " §7= §f" + val);
+        } catch (IOException e) {
+            player.sendMessage("§cFailed to save world metadata!");
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/islands/IslandCommand.java

@@ -1,32 +0,0 @@
-package xyz.soukup.ecoCraftCore.islands;
-
-import com.mojang.brigadier.arguments.StringArgumentType;
-import com.mojang.brigadier.builder.LiteralArgumentBuilder;
-import com.mojang.brigadier.context.CommandContext;
-import io.papermc.paper.command.brigadier.CommandSourceStack;
-import io.papermc.paper.command.brigadier.Commands;
-
-
-public class IslandCommand {
-
-    LiteralArgumentBuilder<CommandSourceStack> tp = Commands.literal("tp")
-            .then(Commands.argument("uuid", StringArgumentType.word())
-                    .executes(IslandCommand::teleport));
-
-    LiteralArgumentBuilder<CommandSourceStack> create = Commands.literal("create")
-            .then(Commands.argument("name", StringArgumentType.word())
-                    .then(Commands.argument("display_name", StringArgumentType.string())));
-
-    private static int teleport(CommandContext<CommandSourceStack> context) {
-        return 0;
-    }
-
-    private static int createWorld(CommandContext<CommandSourceStack> context) {
-        return 0;
-    }
-
-    private static int loadWorld(CommandContext<CommandSourceStack> context) {
-        return 0;
-    }
-
-}

src/main/java/xyz/soukup/ecoCraftCore/islands/IslandManager.java

@@ -1,85 +1,425 @@
 package xyz.soukup.ecoCraftCore.islands;
 
+import com.google.common.io.ByteArrayDataOutput;
+import com.google.common.io.ByteStreams;
 import com.infernalsuite.asp.api.AdvancedSlimePaperAPI;
+import com.infernalsuite.asp.api.exceptions.CorruptedWorldException;
+import com.infernalsuite.asp.api.exceptions.NewerFormatException;
+import com.infernalsuite.asp.api.exceptions.UnknownWorldException;
+import com.infernalsuite.asp.api.exceptions.WorldAlreadyExistsException;
 import com.infernalsuite.asp.api.world.SlimeWorld;
 import com.infernalsuite.asp.api.world.properties.SlimeProperties;
 import com.infernalsuite.asp.api.world.properties.SlimePropertyMap;
-import org.bukkit.Bukkit;
+import com.j256.ormlite.dao.Dao;
+import com.j256.ormlite.dao.GenericRawResults;
+import com.j256.ormlite.stmt.QueryBuilder;
+import com.j256.ormlite.stmt.UpdateBuilder;
+import org.bukkit.*;
+import org.bukkit.entity.Player;
+import org.bukkit.persistence.PersistentDataType;
 import xyz.soukup.ecoCraftCore.database.objects.Island;
 import xyz.soukup.ecoCraftCore.database.DaoRegistry;
+import xyz.soukup.ecoCraftCore.database.objects.TeleportRequest;
+import xyz.soukup.ecoCraftCore.utilities.PDC;
 
+import java.io.IOException;
 import java.sql.SQLException;
+import java.util.Objects;
 import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
 
+import static xyz.soukup.ecoCraftCore.EcoCraftCore.config;
 import static xyz.soukup.ecoCraftCore.EcoCraftCore.plugin;
 
 public class IslandManager {
     private final AdvancedSlimePaperAPI asp = AdvancedSlimePaperAPI.instance();
-    private final IslandLoader loader = new IslandLoader();
+    private final DatabaseIslandLoader databaseLoader = new DatabaseIslandLoader();
+    public final FileIslandLoader fileLoader = new FileIslandLoader();
+    private final Dao<Island, Integer> dao = DaoRegistry.getIslandDao();
 
+    public void createIslandTemplate(String uuid, String templateName){
+        try {
+            SlimeWorld slimeWorld = asp.getLoadedWorld(uuid).clone(templateName, fileLoader);
+            asp.saveWorld(slimeWorld);
+        } catch (WorldAlreadyExistsException e) {
+            throw new RuntimeException(e);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
 
-    public void createIsland(String name, String displayName, String descritpion, String owner, String ownerType) {
+    public String createIsland(String type, String displayName, String descritpion, String owner, String ownerType) {
         String uuid = UUID.randomUUID().toString();
 
-
-        SlimePropertyMap props = new SlimePropertyMap();
-        props.setValue(SlimeProperties.ENVIRONMENT, "overworld");
-        props.setValue(SlimeProperties.WORLD_TYPE, "flat");
-
-        // Create empty world in ASWM
         try {
-            // Note: createEmptyWorld is fast, so we can run some parts sync if needed,
-            // but it's best to run the whole chain async.
             Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
                 try {
-                    // Create the database entry first so the loader has a row to update
 
-
+                    SlimeWorld slimeWorld;
-                    Island island = new Island(name, uuid, displayName, descritpion, owner, ownerType, null);
+                    Island island = new Island(type, uuid, displayName, descritpion, owner, ownerType, null);
                     island.save();
-                    SlimeWorld slimeWorld = asp.createEmptyWorld(uuid, false, props, loader);
 
+                    if (fileLoader.worldExists(type)){
+                        slimeWorld = asp.readWorld(fileLoader, type, false, new SlimePropertyMap()).clone(uuid, databaseLoader);
+                        asp.saveWorld(slimeWorld);
+
+                    }else {
+                        SlimePropertyMap props = new SlimePropertyMap();
+                        props.setValue(SlimeProperties.ENVIRONMENT, "normal");
+                        props.setValue(SlimeProperties.WORLD_TYPE, "flat");
+                        props.setValue(SlimeProperties.ALLOW_ANIMALS, false);
+                        props.setValue(SlimeProperties.ALLOW_MONSTERS, false);
+                        props.setValue(SlimeProperties.SPAWN_X, 0);
+                        props.setValue(SlimeProperties.SPAWN_Y, 2);
+                        props.setValue(SlimeProperties.SPAWN_Z, 0);
+
+                        slimeWorld = asp.createEmptyWorld(uuid, false, props, databaseLoader);
+                        asp.saveWorld(slimeWorld);
+
+                    }
 
-                    Bukkit.getScheduler().runTask(plugin, () -> {
-                        asp.loadWorld(slimeWorld, true);
-                    });
                 } catch (Exception e) { e.printStackTrace(); }
             });
         } catch (Exception e) { e.printStackTrace(); }
+
+        return uuid;
     }
 
-    // 2. Retrieve and Load existing island
+
-    public int loadIsland(String uuid)  {
+
+    public int teleport(Player player, String uuid) throws Exception {
+        return teleport(player, uuid, null, null, null, null, null);
+
+    }
+
+    public int teleport(Player player, String uuid, Integer x, Integer y, Integer z, Float yaw, Float pitch) throws Exception {
+
+        if(uuid == null) return 4;
 
         if (Bukkit.getWorld(uuid) != null){
+            teleportLocally(player, uuid, x, y, z, yaw, pitch);
+            return 2;
+        }
+
+        String whereIsActive = whereIsActive(uuid);
+        if (whereIsActive != null && !whereIsActive.isEmpty()){
+            plugin.getLogger().info("dd: "+ whereIsActive);
+            sendPlayerAway(player, whereIsActive, uuid, x, y, z, yaw, pitch);
+            return 3;
+        }
+
+        QueryBuilder<Island, Integer> queryBuilder = dao.queryBuilder().setCountOf(true);
+        queryBuilder.where().eq("uuid", uuid);
+
+        if (dao.countOf(queryBuilder.prepare()) < 1){
+            return 1;
+        }
+
+        if (player.getVirtualHost() != null){
+            String emptiestServer = getEmptiestServer();
+            if (!Objects.equals(emptiestServer, config.getString("server.name"))){
+                sendPlayerAway(player, emptiestServer, uuid, x, y, z, yaw, pitch);
+            }
+
+        }
+
+        teleportLocally(player, uuid, x, y, z, yaw, pitch);
         return 0;
+
     }
 
-        try {
+    public void teleportLocally(Player player, String uuid,
-            Island island = DaoRegistry.getIslandDao().queryBuilder()
+                                Integer x, Integer y, Integer z,
+                                Float yaw, Float pitch) {
+
+        loadIsland(uuid).thenAccept(world -> {
+
+            Location location = world.getSpawnLocation();
+
+            if (x != null) {
+                location = new Location(world, x, y, z, yaw, pitch);
+            }
+
+            player.teleport(location);
+
+        }).exceptionally(ex -> {
+            ex.printStackTrace();
+            player.sendMessage("§cFailed to load island.");
+            return null;
+        });
+    }
+
+    private String whereIsActive(String uuid) throws SQLException {
+        Island island = dao.queryBuilder()
                 .selectColumns("active_on")
                 .where()
                 .eq("uuid", uuid)
                 .queryForFirst();
 
-            if (!island.getActiveOn().isEmpty()){
+        if (island == null){
-                return 1;
+            return null;
         }
-        } catch (SQLException e) {
+        if (island.getActiveOn() == null){
-            return 2;
+            return null;
+        }
+
+        return island.getActiveOn();
     }
 
+    private void sendPlayerAway(Player player, String server, String uuid, Integer x, Integer y, Integer z, Float yaw, Float pitch) throws SQLException {
+        TeleportRequest teleportRequest = new TeleportRequest(player.getName(), server, uuid, x, y, z, yaw, pitch);
+        teleportRequest.save();
+
+        ByteArrayDataOutput out = ByteStreams.newDataOutput();
+        out.writeUTF("Connect");
+        out.writeUTF(server);
+        player.sendPluginMessage(plugin, "BungeeCord", out.toByteArray());
+    }
+
+    public void loadIslandTemplate(String name){
+        SlimeWorld slimeWorld = null;
+        try {
+            slimeWorld = asp.readWorld(fileLoader, name, false, new SlimePropertyMap());
+            asp.loadWorld(slimeWorld, true);
+
+        } catch (UnknownWorldException e) {
+            throw new RuntimeException(e);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        } catch (CorruptedWorldException e) {
+            throw new RuntimeException(e);
+        } catch (NewerFormatException e) {
+            throw new RuntimeException(e);
+        }
+
+    }
+
+    public CompletableFuture<World> loadIsland(String uuid) {
+
+        CompletableFuture<World> future = new CompletableFuture<>();
+
+        if (Bukkit.getWorld(uuid) != null) {
+            future.complete(Bukkit.getWorld(uuid));
+            return future;
+        }
 
         Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
             try {
 
-                SlimeWorld slimeWorld = asp.readWorld(loader, uuid, false, new SlimePropertyMap());
+                SlimeWorld slimeWorld = asp.readWorld(databaseLoader, uuid, false, new SlimePropertyMap());
+
                 Bukkit.getScheduler().runTask(plugin, () -> {
+                    try {
+
+                        UpdateBuilder updateBuilder = dao.updateBuilder();
+                        updateBuilder.where().eq("uuid", uuid);
+                        updateBuilder.updateColumnValue("active_on", config.getString("server.name"));
+                        updateBuilder.update();
+
                         asp.loadWorld(slimeWorld, true);
+
+                        World world = Bukkit.getWorld(uuid);
+                        if (world != null) {
+                            future.complete(world);
+                        } else {
+                            future.completeExceptionally(
+                                    new IllegalStateException("World loaded but Bukkit returned null"));
+                        }
+
+                    } catch (Exception e) {
+                        future.completeExceptionally(e);
+                    }
                 });
-            } catch (Exception e) { e.printStackTrace(); }
+
+            } catch (Exception e) {
+                future.completeExceptionally(e);
+            }
         });
-        return 0;
+
+        return future;
+    }
+    
+    public void changeSpawn(Location location, String uuid) {
+        SlimeWorld slimeWorld = asp.getLoadedWorld(uuid);
+        SlimePropertyMap slimePropertyMap = slimeWorld.getPropertyMap();
+        slimePropertyMap.setValue(SlimeProperties.SPAWN_X, location.getBlockX());
+        slimePropertyMap.setValue(SlimeProperties.SPAWN_Y, location.getBlockY());
+        slimePropertyMap.setValue(SlimeProperties.SPAWN_Z, location.getBlockZ());
+
+        try {
+            asp.saveWorld(slimeWorld);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void changeEnviroment( String environment, String uuid) {
+        SlimeWorld slimeWorld = asp.getLoadedWorld(uuid);
+        SlimePropertyMap slimePropertyMap = slimeWorld.getPropertyMap();
+        slimePropertyMap.setValue(SlimeProperties.ENVIRONMENT, environment);
+
+        try {
+            asp.saveWorld(slimeWorld);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void expandIsland(float yaw, int lenght, String uuid){
+        World world = Bukkit.getWorld(uuid);
+
+        if (world == null){
+            return;
+        }
+
+        String islandType = (String) PDC.getUniversal(world, "island_type", PersistentDataType.STRING);
+        switch (islandType){
+            case "flat_grass" -> flatExpander(world, yaw, lenght, Material.GRASS_BLOCK, Material.STONE, Material.WATER);
+            case "flat_sand" -> flatExpander(world, yaw, lenght, Material.SAND, Material.STONE, Material.WATER);
+            case "flat_hell" -> flatExpander(world, yaw, lenght, Material.SOUL_SAND, Material.NETHERRACK, Material.LAVA);
+
+
+        }
+
+
+    }
+
+    public void flatExpander(World world, float yaw, int lenght, Material surface, Material base, Material surrounding){
+
+        int x1 = (int) PDC.getUniversal(world, "borderx1", PersistentDataType.INTEGER);
+        int x2 = (int) PDC.getUniversal(world, "borderx2", PersistentDataType.INTEGER);
+        int z1 = (int) PDC.getUniversal(world, "bordery1", PersistentDataType.INTEGER);
+        int z2 = (int) PDC.getUniversal(world, "bordery2", PersistentDataType.INTEGER);
+        int y = world.getMinHeight();
+
+
+        float yawNormalized = yaw % 360f;
+        if (yawNormalized < 0) yawNormalized += 360f;
+
+        int quadrant = Math.round(yawNormalized / 90.0f) & 3;
+
+
+        int xMin;
+        int xMax;
+        int zMin;
+        int zMax;
+
+        switch (quadrant) {
+            case 0:
+                //+Z
+                xMin = Math.min(x1, x2);
+                xMax = Math.max(x1, x2);
+                zMin = Math.max(z1, z2);
+                zMax = zMin + lenght;
+                z2 = Math.min(z1, z2);
+                z1 = zMax;
+
+                break;
+            case 1:
+                //-X
+                zMin = Math.min(z1, z2);
+                zMax = Math.max(z1, z2);
+                xMax = Math.min(x1, x2);
+                xMin = xMax - lenght;
+                x2 = Math.max(x1, x2);
+                x1 = xMin;
+
+                break;
+            case 2:
+                //-Z
+                xMin = Math.min(x1, x2);
+                xMax = Math.max(x1, x2);
+                zMax = Math.min(z1, z2);
+                zMin = zMax - lenght;
+                z2 = Math.max(z1, z2);
+                z1 = zMin;
+
+                break;
+            default:
+                //+X
+                zMin = Math.min(z1, z2);
+                zMax = Math.max(z1, z2);
+                xMin = Math.max(x1, x2);
+                xMax = xMin + lenght;
+                x2 = Math.min(x1, x2);
+                x1 = xMax;
+
+                break;
+
+        }
+
+        for (int x = xMin; x < (xMax + 1); x++) {
+            for (int z = zMin; z < (zMax + 1); z++) {
+                world.setType(x, y, z, base);
+                world.setType(x, y+1, z, base);
+
+                if (((quadrant == 0 || quadrant == 2) && (x == xMin || x == xMax))
+                || ((quadrant == 1 || quadrant == 3) && (z == zMin || z == zMax))) {
+                    continue;
+                }
+
+                if ((quadrant == 0 && z == zMax)
+                || (quadrant == 1 && x == xMin)
+                || (quadrant == 2 && z == zMin)
+                || (quadrant == 3 && x == xMax)){
+                    continue;
+                }
+
+                world.setType(x, y+2, z, surface);
+            }
+        }
+
+        PDC.setUniversal(world, "borderx1", x1, PersistentDataType.INTEGER);
+        PDC.setUniversal(world, "borderx2", x2, PersistentDataType.INTEGER);
+        PDC.setUniversal(world, "bordery1", z1, PersistentDataType.INTEGER);
+        PDC.setUniversal(world, "bordery2", z2, PersistentDataType.INTEGER);
+
+        int chunkMaxX = ((Math.max(x1, x2) + 15) & ~15) + 16;
+        int chunkMinX = (Math.min(x1, x2)  & ~15) - 16;
+        int chunkMaxZ = ((Math.max(z1, z2) + 15) & ~15) + 16;
+        int chunkMinZ = (Math.min(z1, z2)  & ~15) - 16;
+
+        xMin = Math.min(x1, x2);
+        xMax = Math.max(x1, x2);
+        zMin = Math.min(z1, z2);
+        zMax = Math.max(z1, z2);
+
+        for (int x = chunkMinX; x < chunkMaxX + 1; x ++) {
+            for (int z = chunkMinZ; z < chunkMaxZ + 1; z ++) {
+                if ((x >= xMin && x <= xMax) && (z >= zMin && z <= zMax)) {
+                    continue;
+                }
+                world.getBlockAt(x,y,z).setType(surrounding, false);
+                world.getBlockAt(x,y+1,z).setType(surrounding, false);
+
+            }
+        }
+        ;   
+    }
+
+
+
+
+    private String getEmptiestServer() throws Exception {
+        String query = "SELECT active_servers.name " +
+                "FROM active_servers " +
+                "LEFT JOIN islands ON active_servers.name = islands.active_on " +
+                "GROUP BY active_servers.name " +
+                "ORDER BY COUNT(islands.uuid) ASC " +
+                "LIMIT 1";
+
+        GenericRawResults<String[]> rawResults =
+                DaoRegistry.getActiveServerDao().queryRaw(query);
+
+        String[] firstResult = rawResults.getFirstResult();
+        rawResults.close();
+
+        if (firstResult != null && firstResult.length > 0) {
+            String serverName = firstResult[0];
+            return firstResult[0];
+        }
+
+        return null;
     }
 
 

src/main/java/xyz/soukup/ecoCraftCore/islands/IslandSelectorCommand.java

@@ -0,0 +1,188 @@
+package xyz.soukup.ecoCraftCore.islands;
+
+import com.github.stefvanschie.inventoryframework.gui.GuiItem;
+import com.github.stefvanschie.inventoryframework.gui.type.ChestGui;
+import com.github.stefvanschie.inventoryframework.gui.type.HopperGui;
+import com.github.stefvanschie.inventoryframework.pane.OutlinePane;
+import com.github.stefvanschie.inventoryframework.pane.PaginatedPane;
+import com.github.stefvanschie.inventoryframework.pane.component.PagingButtons;
+import com.github.stefvanschie.inventoryframework.pane.util.Slot;
+import com.j256.ormlite.stmt.QueryBuilder;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.context.CommandContext;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.command.brigadier.Commands;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.TextColor;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import xyz.soukup.ecoCraftCore.database.DaoRegistry;
+import xyz.soukup.ecoCraftCore.database.objects.Island;
+import xyz.soukup.ecoCraftCore.database.objects.Region;
+import xyz.soukup.ecoCraftCore.database.objects.RegionMember;
+import xyz.soukup.ecoCraftCore.gui.GuiItemBuilder;
+import xyz.soukup.ecoCraftCore.messages.Messages;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class IslandSelectorCommand {
+
+    public static LiteralArgumentBuilder<CommandSourceStack> getCommand(){
+        return Commands.literal("is")
+                .executes(IslandSelectorCommand::displayIslandListSelectorGui);
+    }
+
+    private static int displayIslandListSelectorGui(CommandContext<CommandSourceStack> context) {
+        String title = LegacyComponentSerializer.legacySection().serialize(Messages.get("menu.island-selector.title"));
+        HopperGui hopperGui = new HopperGui(title);
+        hopperGui.setOnGlobalClick(event -> event.setCancelled(true));
+
+        OutlinePane outlinePane = new OutlinePane(0, 0, 5, 1);
+        Player player = (Player) context.getSource().getSender();
+
+        outlinePane.addItem(selectorItem("menu.island-selector.my-islands", Material.GRASS_BLOCK, getMyIslands(player)));
+        outlinePane.addItem(selectorItem("menu.island-selector.shared-islands", Material.MOSS_BLOCK, getSharedIslands(player)));
+        outlinePane.addItem(selectorItem("menu.island-selector.public-islands", Material.SAND, getPublicIslands()));
+
+        hopperGui.getSlotsComponent().addPane(outlinePane);
+
+        if (player.isOp()){
+            outlinePane.addItem(selectorItem("menu.island-selector.all-islands", Material.CRIMSON_NYLIUM, getAllIslands()));
+        }
+
+        hopperGui.show(player);
+        return 0;
+    }
+
+    private static List<Island> getAllIslands(){
+        QueryBuilder<Island, Integer> queryBuilder = DaoRegistry.getIslandDao().queryBuilder();
+        queryBuilder.selectColumns("display_name", "uuid", "descritpion", "type");
+        try {
+            return queryBuilder.query();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static List<Island> getPublicIslands(){
+        QueryBuilder<Island, Integer> queryBuilder = DaoRegistry.getIslandDao().queryBuilder();
+        queryBuilder.selectColumns("display_name", "uuid", "descritpion", "type");
+        try {
+            queryBuilder.where().eq("is_public", true);
+            return queryBuilder.query();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static List<Island> getMyIslands(Player player){
+        QueryBuilder<Island, Integer> queryBuilder = DaoRegistry.getIslandDao().queryBuilder();
+        queryBuilder.selectColumns("display_name", "uuid", "descritpion", "type");
+        try {
+            queryBuilder.where().eq("owner", player.getName()).and().eq("owner_type", "player");
+            return queryBuilder.query();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static List<Island> getSharedIslands(Player player){
+        QueryBuilder<RegionMember, Integer> memberQb = DaoRegistry.getRegionMemberDao().queryBuilder();
+        memberQb.selectColumns("region_id");
+        try {
+            memberQb.where().eq("member_name", player.getName()).and().eq("member_type", "player");
+
+            QueryBuilder<Region, Integer> regionQb = DaoRegistry.getRegionDao().queryBuilder();
+            regionQb.selectColumns("island");
+            regionQb.where().in("id", memberQb);
+
+            return DaoRegistry.getIslandDao().queryBuilder()
+                    .where()
+                    .in("uuid", regionQb)
+                    .query();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+
+    }
+
+    public static GuiItem selectorItem(String key, Material material, List<Island> islands){
+        GuiItemBuilder guiItemBuilder = new GuiItemBuilder(material);
+        guiItemBuilder.setName(Messages.get(key));
+        GuiItem guiItem = guiItemBuilder.build();
+        guiItem.setAction(event -> openIslandListGui((Player) event.getWhoClicked(), islands));
+        return guiItem;
+    }
+
+
+    private static void openIslandListGui(Player player, List<Island> islands){
+        String title = LegacyComponentSerializer.legacySection().serialize(Messages.get("menu.island-selector.title"));
+        ChestGui chestGui = new ChestGui(4, title);
+        chestGui.setOnGlobalClick(event -> event.setCancelled(true));
+
+        PaginatedPane paginatedPane = new PaginatedPane(0, 0, 9, 3);
+
+        paginatedPane.populateWithGuiItems(itemsFromIslands(player, islands));
+        PagingButtons pagingButtons = new PagingButtons(Slot.fromXY(0, 3), 9, paginatedPane);
+
+        chestGui.addPane(paginatedPane);
+        chestGui.addPane(pagingButtons);
+
+        chestGui.show(player);
+    }
+
+
+    private static List<GuiItem> itemsFromIslands(Player player, List<Island> islands){
+        List<GuiItem> guiItems = new ArrayList<>();
+        IslandManager islandManager = new IslandManager();
+        for (Island island : islands){
+            Material material;
+            TextColor color;
+
+            switch (island.getType()){
+                case "flat_grass":
+                    material = Material.GRASS_BLOCK;
+                    color = TextColor.color(0x02bd02);
+                    break;
+                case "flat_sand":
+                    material = Material.SAND;
+                    color = TextColor.color(0xfccf03);
+                    break;
+                case "flat_hell":
+                    material = Material.SOUL_SAND;
+                    color = TextColor.color(0xf00707);
+                    break;
+                case "void":
+                    material = Material.GLASS;
+                    color = TextColor.color(0xffffff);
+                    break;
+                default:
+                    material = Material.WHITE_WOOL;
+                    color = TextColor.color(0xffffff);
+                    break;
+            }
+
+
+            GuiItemBuilder guiItemBuilder = new GuiItemBuilder(material);
+            guiItemBuilder.setName(Component.text(island.getDisplayName(), color));
+            guiItemBuilder.setRawLore(island.getDescritpion());
+
+            GuiItem guiItem = guiItemBuilder.build();
+            guiItem.setAction(event -> {
+                try {
+                    islandManager.teleport(player, island.getUuid());
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            });
+
+            guiItems.add(guiItem);
+
+        }
+        return guiItems;
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/islands/UnloadIsland.java

@@ -1,4 +1,4 @@
 package xyz.soukup.ecoCraftCore.islands;
 
-public class UnloadWorld {
+public class UnloadIsland {
 }

src/main/java/xyz/soukup/ecoCraftCore/money/MoneyCommand.java

@@ -19,7 +19,7 @@ import xyz.soukup.ecoCraftCore.messages.PHHM;
 
 public class MoneyCommand {
 
-    public static LiteralArgumentBuilder<CommandSourceStack> createCommand() {
+    public static LiteralArgumentBuilder<CommandSourceStack> getCommand() {
         // 1. Send Branch
         LiteralArgumentBuilder<CommandSourceStack> send = Commands.literal("send")
                 .requires(source -> source.getSender() instanceof Player)

src/main/java/xyz/soukup/ecoCraftCore/player/OnKill.java

@@ -0,0 +1,27 @@
+package xyz.soukup.ecoCraftCore.player;
+
+import com.destroystokyo.paper.event.player.PlayerPostRespawnEvent;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerRespawnEvent;
+import xyz.soukup.ecoCraftCore.islands.IslandManager;
+
+import static xyz.soukup.ecoCraftCore.EcoCraftCore.config;
+
+public class OnKill implements Listener {
+    @EventHandler
+    public void spawnTeleportOnKill(PlayerPostRespawnEvent event){
+        Player player = event.getPlayer();
+
+        String uuid = config.getString("islands.spawn");
+
+        IslandManager islandManager = new IslandManager();
+        try {
+            islandManager.teleport(player, uuid);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/player/TeleportRequestsHandler.java

@@ -0,0 +1,50 @@
+package xyz.soukup.ecoCraftCore.player;
+
+import com.google.common.eventbus.DeadEvent;
+import com.j256.ormlite.stmt.QueryBuilder;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import xyz.soukup.ecoCraftCore.database.DaoRegistry;
+import xyz.soukup.ecoCraftCore.database.objects.TeleportRequest;
+import xyz.soukup.ecoCraftCore.islands.IslandManager;
+
+import java.sql.SQLException;
+
+import static xyz.soukup.ecoCraftCore.EcoCraftCore.config;
+
+public class TeleportRequestsHandler implements Listener {
+
+    @EventHandler
+    public void teleportRequestHandler(PlayerJoinEvent event){
+        try {
+            Player player = event.getPlayer();
+
+            QueryBuilder<TeleportRequest, Integer> queryBuilder = DaoRegistry.getTeleportRequestsDao().queryBuilder();
+            queryBuilder.where().eq("player", player.getName());
+
+            TeleportRequest teleportRequest = queryBuilder.queryForFirst();
+
+            IslandManager islandManager = new IslandManager();
+
+
+            if (teleportRequest == null){
+                islandManager.teleport(player, config.getString("islands.spawn"));
+                return;
+            }
+
+
+            islandManager.teleportLocally(player, teleportRequest.getWorld(), teleportRequest.getX(), teleportRequest.getY(), teleportRequest.getY(), teleportRequest.getYaw(), teleportRequest.getPitch());
+
+            teleportRequest.delete();
+
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+}

src/main/java/xyz/soukup/ecoCraftCore/positionMarker/MarkerCommand.java

@@ -11,22 +11,21 @@ import org.bukkit.inventory.ItemStack;
 import xyz.soukup.ecoCraftCore.messages.Messages;
 import xyz.soukup.ecoCraftCore.utilities.PDC;
 
-public class RulerCommand {
+public class MarkerCommand {
-    public static LiteralArgumentBuilder<CommandSourceStack> createCommand() {
+    public static LiteralArgumentBuilder<CommandSourceStack> getCommand() {
         return Commands.literal("ruler")
-                .executes(RulerCommand::obtainRuler);
+                .executes(MarkerCommand::obtainRuler);
     }
 
     private static int obtainRuler(CommandContext<CommandSourceStack> context){
 
         CommandSender commandSender = context.getSource().getSender();
 
-        if (!(commandSender instanceof Player)){
+        if (!(commandSender instanceof Player player)){
             Messages.send(commandSender, "generic.error.not-player");
             return 0;
         }
 
-        Player player = (Player) commandSender;
         ItemStack itemStack = new ItemStack(Material.BLAZE_ROD);
         PDC.set(itemStack, "ruler", true);
 

src/main/java/xyz/soukup/ecoCraftCore/positionMarker/MarkerEvent.java

@@ -16,7 +16,7 @@ import xyz.soukup.ecoCraftCore.messages.PHHM;
 
 import java.util.HashMap;
 
-public class RulerMarking implements Listener {
+public class MarkerEvent implements Listener {
 
     public static HashMap<Player, Location> primaryLocations = new HashMap<>();
     public static HashMap<Player, Location> secondaryLocations = new HashMap<>();

src/main/java/xyz/soukup/ecoCraftCore/regions/RegionAdminCommand.java

@@ -0,0 +1,38 @@
+package xyz.soukup.ecoCraftCore.regions;
+
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.context.CommandContext;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.command.brigadier.Commands;
+import org.bukkit.entity.Player;
+import xyz.soukup.ecoCraftCore.messages.Messages;
+
+public class RegionAdminCommand {
+    public static LiteralArgumentBuilder<CommandSourceStack> createCommand() {
+        LiteralArgumentBuilder<CommandSourceStack> create = Commands.literal("create")
+                .then(Commands.argument("type", IntegerArgumentType.integer(0, 1)))
+                .executes(RegionAdminCommand::createRegion);
+
+        return Commands.literal("region")
+                .then(create);
+    }
+
+    private static int createRegion(CommandContext<CommandSourceStack> context) {
+        Integer type = context.getArgument("type", Integer.class);
+        if(!(context.getSource().getSender() instanceof Player player)){
+            Messages.send(context.getSource().getSender(), "generic.error.not-player");
+            return 0;
+        };
+
+        int status = RegionManager.createRegion(player, type, player.getName(), "player");
+
+        switch (status){
+            case 0 -> Messages.send(player, "generic.success.created");
+            case 1 -> Messages.send(player, "region.error.not-marked");
+            case 2 -> Messages.send(player, "region.error.not-same-world");
+        }
+
+        return 0;
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/regions/RegionEvents.java

@@ -0,0 +1,36 @@
+package xyz.soukup.ecoCraftCore.regions;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import xyz.soukup.ecoCraftCore.database.objects.Region;
+import xyz.soukup.ecoCraftCore.database.objects.RegionMember;
+
+public class RegionEvents implements Listener {
+
+    @EventHandler
+    public void onPlayerInteract(PlayerInteractEvent event){
+        event.setCancelled(!isRegionMember(event.getClickedBlock().getWorld().getName(), event.getPlayer(), event.getClickedBlock().getX(), event.getClickedBlock().getY()));
+    }
+
+
+    private boolean isRegionMember(String island, Player player, int x, int y){
+        Region region = Region.findRegion(x, y, island);
+
+            if (region == null){
+                return false;
+            }
+
+            String name = player.getName();
+
+            for (RegionMember regionMember : region.getRegionMembers()){
+                if (regionMember.getMembertype().equals("player") && regionMember.getName().equals(name)){
+                    return true;
+                }
+            }
+
+            return false;
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/regions/RegionManager.java

@@ -0,0 +1,34 @@
+package xyz.soukup.ecoCraftCore.regions;
+
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import xyz.soukup.ecoCraftCore.database.objects.Region;
+import xyz.soukup.ecoCraftCore.positionMarker.MarkerEvent;
+
+public class RegionManager {
+    public static int createRegion(Player player, Integer type, String owner, String ownerType){
+        Location primaryLocation = MarkerEvent.primaryLocations.get(player);
+        Location secondaryLocation = MarkerEvent.secondaryLocations.get(player);
+
+        if (primaryLocation == null || secondaryLocation == null){
+            return 1;
+        }
+
+        if (primaryLocation.getWorld() != secondaryLocation.getWorld()){
+            return 2;
+        }
+
+        String worldName = primaryLocation.getWorld().getName();
+        int x1 = primaryLocation.getBlockX();
+        int y1 = primaryLocation.getBlockZ();
+        int x2 = secondaryLocation.getBlockX();
+        int y2 = secondaryLocation.getBlockZ();
+
+        Region region = new Region(worldName, type, x1, y1, x2, y2);
+        region.save();
+
+        region.addRegionMember(ownerType, owner, "owner");
+
+        return 0;
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/shop/ShopCommand.java

@@ -9,17 +9,16 @@ import org.bukkit.block.Chest;
 import org.bukkit.block.Sign;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
-import xyz.soukup.ecoCraftCore.positionMarker.RulerMarking;
+import xyz.soukup.ecoCraftCore.positionMarker.MarkerEvent;
 import xyz.soukup.ecoCraftCore.database.objects.Shop;
 import xyz.soukup.ecoCraftCore.inventory.VirtualChest;
 import xyz.soukup.ecoCraftCore.inventory.InventoryUtils;
 import xyz.soukup.ecoCraftCore.messages.Messages;
 import xyz.soukup.ecoCraftCore.utilities.PDC;
 
-@SuppressWarnings("UnstableApiUsage")
 public class ShopCommand {
 
-    public static LiteralArgumentBuilder<CommandSourceStack> createCommand() {
+    public static LiteralArgumentBuilder<CommandSourceStack> getCommand() {
         // Define the argument types
         var amountArg = Commands.argument("amount", IntegerArgumentType.integer(1));
         var buyPriceArg = Commands.argument("buy_price", FloatArgumentType.floatArg(0.0F));
@@ -52,8 +51,8 @@ public class ShopCommand {
         }
 
         // 1. Check if blocks are marked
-        Chest chest = RulerMarking.chests.get(player);
+        Chest chest = MarkerEvent.chests.get(player);
-        Sign sign = RulerMarking.signs.get(player);
+        Sign sign = MarkerEvent.signs.get(player);
 
         if (sign == null || chest == null) {
             Messages.send(player, "shop.error.not-marked");

src/main/java/xyz/soukup/ecoCraftCore/utilities/PDC.java

@@ -9,11 +9,15 @@ import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.persistence.PersistentDataContainer;
 import org.bukkit.persistence.PersistentDataHolder;
 import org.bukkit.persistence.PersistentDataType;
+import xyz.soukup.ecoCraftCore.EcoCraftCore;
+
+import static xyz.soukup.ecoCraftCore.EcoCraftCore.plugin;
 
 @SuppressWarnings({"unchecked", "rawtypes"})
 public class PDC {
 
 
+
     //TileState
 
     public static void set(TileState tileState, String key, Integer value){
@@ -65,7 +69,7 @@ public class PDC {
         return (String) get(itemStack, key, PersistentDataType.STRING);
     }
 
-    private static Object get(ItemStack itemStack, String key, PersistentDataType persistentDataType){
+    public static Object get(ItemStack itemStack, String key, PersistentDataType persistentDataType){
         ItemMeta itemMeta = itemStack.getItemMeta();
         return getUniversal(itemMeta, key, persistentDataType);
     }
@@ -80,15 +84,15 @@ public class PDC {
 
     //Univerzální set & get
     
-    private static Object getUniversal(PersistentDataHolder persistentDataHolder, String key, PersistentDataType persistentDataType){
+    public static Object getUniversal(PersistentDataHolder persistentDataHolder, String key, PersistentDataType persistentDataType){
         PersistentDataContainer persistentDataContainer = persistentDataHolder.getPersistentDataContainer();
-        NamespacedKey namespacedKey = new NamespacedKey("ecc", key);
+        NamespacedKey namespacedKey = new NamespacedKey(plugin, key);
         return persistentDataContainer.get(namespacedKey, persistentDataType);
     }
     
-    private static void setUniversal(PersistentDataHolder persistentDataHolder, String key, Object value, PersistentDataType persistentDataType){
+    public static void setUniversal(PersistentDataHolder persistentDataHolder, String key, Object value, PersistentDataType persistentDataType){
         PersistentDataContainer persistentDataContainer = persistentDataHolder.getPersistentDataContainer();
-        NamespacedKey namespacedKey = new NamespacedKey("ecc", key);
+        NamespacedKey namespacedKey = new NamespacedKey(plugin, key);
         persistentDataContainer.set(namespacedKey, persistentDataType, value);
 
     }

src/main/resources/config.yml

@@ -10,3 +10,5 @@ database:
   database: "ecc"
 cache:
   save-interval: 6000
+islands:
+  spawn: null

src/main/resources/messages.yml

@@ -1,4 +1,6 @@
 generic:
+  success:
+    creat ed: <green>Vytvořeno.
   error:
     not-player: "<red>Na tuto akci musíš být hráč"
     no-funds:
@@ -10,6 +12,9 @@ generic:
     no-item:
       self: "<red>Nemáš dostatek itemů"
       shop: "<red>Obchod nemá dostatek itemů"
+region:
+  error:
+    not-marked: "<red>Musíš nejprve označit pozice"
 shop:
   error:
     already-shop: "<red>Tato cedule již je obchod"
@@ -44,6 +49,12 @@ marker:
     primary: "<green>První pozice označena (<x>,<y>,<z>)"
     secondary: "<green>Druhá pozice označena (<x>,<y>,<z>)"
 menu:
+  island-selector:
+    title: "<green><bold>Výběr ostrovu"
+    my-islands: "<yellow><bold>Moje ostrovy"
+    shared-islands: "<blue><bold>Ostrovy sdílené se mnou"
+    public-islands: "<green><bold>Veřejné Ostrovy"
+    all-islands: "<red><bold>Všechny ostrovy (Pouze OP)"
   shop:
     buy: "<green>Koupit <amount>ks za <price>$"
     sell: "<yellow>Prodat <amount>ks za <price>$"

src/main/resources/plugin.yml

@@ -2,3 +2,6 @@ name: EcoCraftCore
 version: '1.0-SNAPSHOT'
 main: xyz.soukup.ecoCraftCore.EcoCraftCore
 api-version: '1.21'
+depend:
+  - packetevents
+