Já mám právo sedět!

- confirm menu

pom.xml

@@ -28,6 +28,16 @@
                     <target>${java.version}</target>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-resources-plugin</artifactId>
+                <version>3.3.1</version>
+                <configuration>
+                    <nonFilteredFileExtensions>
+                        <nonFilteredFileExtension>slime</nonFilteredFileExtension>
+                    </nonFilteredFileExtensions>
+                </configuration>
+            </plugin>
 
             <plugin>
                 <groupId>io.ebean</groupId>
@@ -82,11 +92,20 @@
             <resource>
                 <directory>src/main/resources</directory>
                 <filtering>true</filtering>
+              
             </resource>
         </resources>
     </build>
 
     <repositories>
+        <repository>
+            <id>enginehub</id>
+            <url>https://maven.enginehub.org/repo/</url>
+        </repository>
+        <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 +122,8 @@
             <id>jitpack.io</id>
             <url>https://jitpack.io</url>
         </repository>
+
+
     </repositories>
 
     <dependencies>
@@ -133,6 +154,12 @@
             <version>1.21.10-R0.1-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.sk89q.worldedit</groupId>
+            <artifactId>worldedit-bukkit</artifactId>
+            <version>7.3.12</version>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.github.stefvanschie.inventoryframework</groupId>
             <artifactId>IF</artifactId>
@@ -143,5 +170,16 @@
             <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>
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP</artifactId>
+            <version>6.2.1</version>
+        </dependency>
     </dependencies>
 </project>

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

@@ -1,27 +1,52 @@
 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.jdbc.DataSourceConnectionSource;
+import com.j256.ormlite.stmt.UpdateBuilder;
 import com.j256.ormlite.support.ConnectionSource;
 import com.j256.ormlite.table.TableUtils;
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+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.messages.JoinLeaveMessageSupress;
+import xyz.soukup.ecoCraftCore.mines.MineCommand;
+import xyz.soukup.ecoCraftCore.mines.MineWorldManager;
 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.regions.RegionAdminCommand;
+import xyz.soukup.ecoCraftCore.regions.RegionEvents;
 import xyz.soukup.ecoCraftCore.shop.ShopCommand;
 import xyz.soukup.ecoCraftCore.database.objects.Account;
+import xyz.soukup.ecoCraftCore.database.objects.Island;
 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.database.objects.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;
+import xyz.soukup.ecoCraftCore.sign.SignEditCommand;
+import xyz.soukup.ecoCraftCore.sit.LetMeSit;
 import xyz.soukup.ecoCraftCore.virtualChest.VirtualChestLogic;
 
 import java.io.IOException;
@@ -29,30 +54,49 @@ 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();
+            prepareWorldInactivityUnloader();
+
+        }catch (IOException e) {
             e.printStackTrace();
-            getLogger().severe("Failed to initialize database.");
+            getLogger().severe("Failed to save island templates.");
-        } catch (IOException e) {
-            throw new RuntimeException(e);
         }
 
+        MineWorldManager.init();
+
         this.getServer().getScheduler().runTaskTimer(this, /* Lambda: */ task -> {
             VirtualChest.saveCache();
         } , 6000, 6000);
@@ -62,53 +106,210 @@ public final class EcoCraftCore extends JavaPlugin {
     @Override
     public void onDisable() {
 
+        plugin.saveConfig();
         VirtualChest.saveCache();
+        saveSlimeWorlds();
+        adiosDatabase();
 
-        try {
+        PacketEvents.getAPI().terminate();
-            if (connectionSource != null) {
+
-                connectionSource.close();
+    }
+
+    private void prepareSlimeWorldsSaver(){
+        Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, () -> {
+            AdvancedSlimePaperAPI asp = AdvancedSlimePaperAPI.instance();
+
+            for (SlimeWorldInstance slimeWorldInstance : asp.getLoadedWorlds()){
+                getLogger().info("Saved database world " + slimeWorldInstance.getName());
+                try {
+                    asp.saveWorld(slimeWorldInstance);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
             }
-        } catch (Exception e) {
+        }, 12000L, 12000L);
-            e.printStackTrace();
+    }
+
+    private void prepareWorldInactivityUnloader(){
+        Bukkit.getScheduler().runTaskTimer(plugin, () -> {
+
+            long timeoutMillis = 6 * 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);
+                    getLogger().info("Unloading world " + world.getName() + " due to inactivity");
+                    try {
+                        UpdateBuilder<Island, Integer> updateBuilder = DaoRegistry.getIslandDao().updateBuilder();
+                        updateBuilder.where().eq("uuid", world.getName());
+                        updateBuilder.updateColumnValue("active_on", "");
+                        updateBuilder.update();
+                    } catch (SQLException e) {
+                        throw new RuntimeException(e);
+                    }
+
+                }
+
+
+
+            }
+
+        }, 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 prepareDatabase() throws SQLException {
+    private void saveIslandTemplates(){
-        String databaseUrl = "jdbc:mysql://localhost:3306/ecc";
+        plugin.saveResource("island_templates/flat_grass.slime", false);
-        connectionSource = new JdbcConnectionSource(databaseUrl, "ecc", "ecc");
+        plugin.saveResource("island_templates/flat_sand.slime", false);
-        Logger.getLogger("com.j256.ormlite.table.TableUtils").setLevel(Level.OFF);
+        plugin.saveResource("island_templates/flat_hell.slime", false);
 
 
-        TableUtils.createTableIfNotExists(connectionSource, Transaction.class);
+    }
-        TableUtils.createTableIfNotExists(connectionSource, Shop.class);
-        TableUtils.createTableIfNotExists(connectionSource, VirtualChest.class);
-        TableUtils.createTableIfNotExists(connectionSource, Account.class);
 
-        DaoRegistry.setTransactionDao(DaoManager.createDao(connectionSource, Transaction.class));
+    private void prepareDatabase() {
-        DaoRegistry.setShopDao(DaoManager.createDao(connectionSource, Shop.class));
+
-        DaoRegistry.setVirtualChestDao(DaoManager.createDao(connectionSource, VirtualChest.class));
+        try {
-        DaoRegistry.setAccountDao(DaoManager.createDao(connectionSource, Account.class));
+            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;
+
+            HikariConfig hikariConfig = new HikariConfig();
+            hikariConfig.setJdbcUrl(databaseUrl);
+            hikariConfig.setUsername(databaseUsername);
+            hikariConfig.setPassword(databasePassword);
+            hikariConfig.setMaximumPoolSize(5);
+            hikariConfig.setKeepaliveTime(60000);
+            hikariConfig.setMaxLifetime(1800000);
+
+            HikariDataSource dataSource = new HikariDataSource(hikariConfig);
+
+            connectionSource = new DataSourceConnectionSource(dataSource, databaseUrl);
+            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()));
+        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(RegionAdminCommand.getCommand().build()));
+        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(ShopCommand.getCommand().build()));
+        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(MarkerCommand.getCommand().build()));
+        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(MoneyCommand.getCommand().build()));
+        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(MineCommand.createCommand().build()));
+        lm.registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(SignEditCommand.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);
+        pm.registerEvents(new RegionEvents(), this);
+        pm.registerEvents(new MineWorldManager(), this);
+        pm.registerEvents(new JoinLeaveMessageSupress(), this);
+        pm.registerEvents(new LetMeSit(), this);
 
-    }
+        EventManager events = PacketEvents.getAPI().getEventManager();
+        events.registerListener(new ChunkModifier(this), PacketListenerPriority.NORMAL);
 
+    }
 
 
 

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

@@ -2,7 +2,7 @@ package xyz.soukup.ecoCraftCore.database;
 
 import com.j256.ormlite.dao.Dao;
 import xyz.soukup.ecoCraftCore.database.objects.*;
-import xyz.soukup.ecoCraftCore.inventory.VirtualChest;
+import xyz.soukup.ecoCraftCore.database.objects.VirtualChest;
 
 public class    DaoRegistry {
     private static Dao<Shop, Integer> shopDao;
@@ -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() {
@@ -98,10 +109,25 @@ public class Island {
         }
     }
 
+    public static Island findByUuid(String uuid) {
+        try {
+            return DaoRegistry.getIslandDao().queryBuilder().where().eq("uuid", uuid).queryForFirst();
+        } catch (SQLException e) {
+            return null;
+        }
+    }
+
 
 
     public void save(){
         try {
+            // createOrUpdate works by primary id; resolve id from uuid first to avoid duplicate inserts.
+            if (this.id <= 0 && this.uuid != null) {
+                Island existing = findByUuid(this.uuid);
+                if (existing != null) {
+                    this.id = existing.id;
+                }
+            }
             DaoRegistry.getIslandDao().createOrUpdate(this);
         } catch (SQLException e) {
             throw new RuntimeException(e);

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

@@ -0,0 +1,213 @@
+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 z1;
+
+    @DatabaseField(canBeNull = false)
+    private int x2;
+
+    @DatabaseField(canBeNull = false)
+    private int y2;
+
+    @DatabaseField(canBeNull = false)
+    private int z2;
+
+    @ForeignCollectionField(eager = true)
+    private ForeignCollection<RegionMember> regionMembers;
+
+    @DatabaseField()
+    private Integer value;
+
+    public Region() {
+
+    }
+
+    public Region(String island, int regionType, int x1, int y1, int z1, int x2, int y2, int z2) {
+        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);
+        this.z1 = Math.min(z1, z2);
+        this.z2 = Math.max(z1, z2);
+
+    }
+    public int getId() {
+        return id;
+    }
+
+    public int getRegionType() {
+        return regionType;
+    }
+
+    public int getX1() {
+        return x1;
+    }
+
+    public int getZ1() {
+        return z1;
+    }
+
+    public int getZ2() {
+        return z2;
+    }
+
+    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);
+            List<Region> regions = cache.get(island);
+
+            if (regions == null) {
+                return;
+            }
+
+            regions.removeIf(region -> region.getId() == this.id);
+            regions.add(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();
+
+        Region updatedRegion = Region.findById(this.id);
+        List<Region> regions = cache.get(island);
+
+        if (regions == null) {
+            return;
+        }
+
+        regions.removeIf(region -> region.getId() == this.id);
+        regions.add(updatedRegion);
+
+    }
+
+    public boolean isInside(int x, int y, int z) {
+        return x >= this.x1 && x <= this.x2 && y >= this.y1 && y <= this.y2 && z >= this.z1 && z <= this.z2;
+    }
+    
+    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, int z, 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, z)) {
+                continue;
+            }
+            if (highestType >= cachedRegion.getRegionType()){
+                continue;
+            }
+            region = cachedRegion;
+        }
+
+        return region;
+
+
+    }
+
+    public void changeBoundaries(int x1, int y1, int z1, int x2, int y2, int z2){
+        this.x1 = Math.min(x1, x2);
+        this.y1 = Math.min(y1, y2);
+        this.x2 = Math.max(x1, x2);
+        this.y2 = Math.max(y1, y2);
+        this.z1 = Math.min(z1, z2);
+        this.z2 = Math.max(z1, z2);
+    }
+
+
+}
+

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/Shop.java

@@ -7,6 +7,7 @@ import org.bukkit.block.sign.Side;
 import org.bukkit.block.sign.SignSide;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.persistence.PersistentDataType;
 import org.jetbrains.annotations.NotNull;
 import xyz.soukup.ecoCraftCore.database.DaoRegistry;
 import xyz.soukup.ecoCraftCore.utilities.Converter;
@@ -102,6 +103,7 @@ public class Shop {
         this.stock = stock;
     }
 
+
     public static Shop findById(int id) {
         Shop shop = cache.get(id);
 
@@ -116,6 +118,10 @@ public class Shop {
         }
     }
 
+    public static HashMap<Integer, Shop> getCache(){
+        return cache;
+    }
+
     public void save(){
         try {
             DaoRegistry.getShopDao().createOrUpdate(this);
@@ -126,13 +132,29 @@ public class Shop {
         cache.put(this.id, this);
     }
 
+    public void delete(){
+        try {
+            cache.remove(this.id);
+            DaoRegistry.getShopDao().delete(this);
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+
+    }
+
     public ItemStack getItemStack() {
         return Converter.itemstackFromString(this.itemStackString);
     }
 
+
     public void writeIntoSign(Sign sign){
         PDC.set(sign, "shop", this.id);
 
+        if (PDC.getUniversal(sign, "line1", PersistentDataType.STRING) != null){
+            sign.update();
+            return;
+        }
+
         Component prices;
         Component shopType;
 
@@ -159,7 +181,7 @@ public class Shop {
 
     }
 
-    public long getId() {
+    public int getId() {
         return id;
     }
 

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/database/objects/VirtualChest.java

@@ -1,18 +1,22 @@
-package xyz.soukup.ecoCraftCore.inventory;
+package xyz.soukup.ecoCraftCore.database.objects;
 
 import com.j256.ormlite.field.DataType;
 import com.j256.ormlite.field.DatabaseField;
+import com.j256.ormlite.stmt.DeleteBuilder;
+import com.j256.ormlite.stmt.QueryBuilder;
 import com.j256.ormlite.table.DatabaseTable;
 import org.bukkit.block.Chest;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
 import xyz.soukup.ecoCraftCore.database.DaoRegistry;
+import xyz.soukup.ecoCraftCore.inventory.InventoryUtils;
 import xyz.soukup.ecoCraftCore.utilities.Converter;
 import xyz.soukup.ecoCraftCore.utilities.PDC;
 
 import java.sql.SQLException;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 
 @DatabaseTable(tableName = "virtual_chests")
 public class VirtualChest {
@@ -29,7 +33,7 @@ public class VirtualChest {
     private Inventory inventory;
 
     private static final HashMap<Integer,  VirtualChest> cache = new HashMap<>();
-    private static final HashSet<Integer> cacheChanges = new HashSet<>();
+    private static final HashSet<Integer> changedCached = new HashSet<>();
 
     public VirtualChest(){
 
@@ -77,7 +81,7 @@ public class VirtualChest {
 
     public static void saveCache(){
         cache.forEach((key, value) -> {
-            if (!cacheChanges.contains(key)) return;
+            if (!changedCached.contains(key)) return;
 
             value.databaseSave();
         });
@@ -87,7 +91,7 @@ public class VirtualChest {
 
     public void save() {
         cache.put(this.id, this);
-        cacheChanges.add(this.id);
+        changedCached.add(this.id);
     }
 
     public void databaseSave(){
@@ -101,7 +105,40 @@ public class VirtualChest {
         }
 
         cache.put(this.id, this);
-        cacheChanges.remove(this.id);
+        changedCached.remove(this.id);
+    }
+
+    public void delete(){
+        try {
+            DaoRegistry.getVirtualChestDao().delete(this);
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void deleteSelfAndShops(){
+        QueryBuilder<Shop, Integer> queryBuilder = DaoRegistry.getShopDao().queryBuilder();
+        DeleteBuilder<Shop, Integer> deleteBuilder = DaoRegistry.getShopDao().deleteBuilder();
+        try {
+            queryBuilder
+                    .selectColumns("id")
+                    .where()
+                    .eq("virtualChestID", this.id);
+
+            List<Shop> shops = queryBuilder.query();
+            HashMap<Integer, Shop> cache = Shop.getCache();
+
+            for(Shop shop : shops){
+                cache.remove(shop.getId());
+            }
+
+            deleteBuilder.where().eq("virtualChestID", this.id);
+            deleteBuilder.delete();
+
+            DaoRegistry.getVirtualChestDao().delete(this);
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
     }
 
     public void setInventory(Inventory inventory) {

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,347 @@
+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.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Registry;
+import org.bukkit.block.Biome;
+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> setBiome = Commands.literal("biome")
+                .then(Commands.argument("biome", StringArgumentType.string())
+                        .suggests(((context, builder) -> {
+                            Registry<Biome> biomeRegistry = Registry.BIOME;
+                            biomeRegistry.stream().forEach(biome -> builder.suggest(biome.getKey().asString()));
+                            return builder.buildFuture();
+                        }))
+                        .executes(IslandAdminCommand::setBiome));
+
+        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)
+                .then(setBiome);
+
+
+
+    }
+
+    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 setBiome(CommandContext<CommandSourceStack> context) {
+        if (!(context.getSource().getSender() instanceof Player player)) return 0;
+        IslandManager islandManager = new IslandManager();
+        String uuid = player.getWorld().getName();
+        islandManager.changeBiome(context.getArgument("biome", String.class), uuid);
+        Messages.send(player, "island.set-biome.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,471 @@
 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.Region;
+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(); }
+
+        createWorldRegion(uuid, owner, ownerType, type);
+
+        return uuid;
     }
 
-    // 2. Retrieve and Load existing island
-    public int loadIsland(String uuid)  {
 
-        if (Bukkit.getWorld(uuid) != null) {
+
-            return 0;
+    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;
         }
 
-        try {
+        String whereIsActive = whereIsActive(uuid);
-            Island island = DaoRegistry.getIslandDao().queryBuilder()
+        if (whereIsActive != null && !whereIsActive.isEmpty()){
-                    .selectColumns("active_on")
+            plugin.getLogger().info("dd: "+ whereIsActive);
-                    .where()
+            sendPlayerAway(player, whereIsActive, uuid, x, y, z, yaw, pitch);
-                    .eq("uuid", uuid)
+            return 3;
-                    .queryForFirst();
+        }
-
+
-            if (!island.getActiveOn().isEmpty()){
+        QueryBuilder<Island, Integer> queryBuilder = dao.queryBuilder().setCountOf(true);
-                return 1;
+        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);
             }
-        } catch (SQLException e) {
+
-            return 2;
+        }
+
+        teleportLocally(player, uuid, x, y, z, yaw, pitch);
+        return 0;
+
+    }
+
+    public void teleportLocally(Player player, String uuid,
+                                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 == null){
+            return null;
+        }
+        if (island.getActiveOn() == null){
+            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, () -> {
-                    asp.loadWorld(slimeWorld, true);
+                    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;
+    }
+
+    private void createWorldRegion(String uuid, String owner, String ownerType, String islandType) {
+        int x1 = -32;
+        int x2 = 31;
+        int y1 = -64;
+        int y2 = 320;
+        int z1 = -32;
+        int z2 = 31;
+
+
+        Region region = new Region(uuid, -1, x1, y1, z1, x2, y2, z2);
+        region.save();
+        region.addRegionMember(ownerType, owner, "owner");
+    }
+    
+    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 changeBiome(String biome, String uuid){
+        SlimeWorld slimeWorld = asp.getLoadedWorld(uuid);
+        SlimePropertyMap slimePropertyMap = slimeWorld.getPropertyMap();
+        slimePropertyMap.setValue(SlimeProperties.DEFAULT_BIOME, biome);
+
+        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);
+            }
+        }
+
+        changeBoundaries(world, x1, x2, z1, z2);
+
+        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 void changeBoundaries(World world, int x1, int x2, int z1, int z2){
+        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);
+
+        QueryBuilder<Region, Integer> queryBuilder = DaoRegistry.getRegionDao().queryBuilder();
+        try {
+            queryBuilder.where()
+                    .eq("island", world.getName())
+                    .and()
+                    .eq("region_type", 0);
+            Region region = queryBuilder.queryForFirst();
+            region.changeBoundaries(x1, 320, z1, x2,-64, z2);
+            region.save();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+
+
+
+    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/messages/JoinLeaveMessageSupress.java

@@ -0,0 +1,18 @@
+package xyz.soukup.ecoCraftCore.messages;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+public class JoinLeaveMessageSupress implements Listener {
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) {
+        event.joinMessage(null);
+    }
+
+    @EventHandler
+    public void onQuit(PlayerQuitEvent event) {
+        event.quitMessage(null);
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/messages/Messages.java

@@ -4,6 +4,7 @@ import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
 import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
 import org.bukkit.command.CommandSender;
 import org.bukkit.configuration.file.YamlConfiguration;
 
@@ -39,7 +40,7 @@ public class Messages {
     }
 
     public static String getAsString(String key){
-        return MiniMessage.miniMessage().serialize(Messages.get(key));
+        return LegacyComponentSerializer.legacySection().serialize(Messages.get(key));
     }
 
     public static Component get(String key, HashMap<String, String> placeholders){

src/main/java/xyz/soukup/ecoCraftCore/mines/MineCommand.java

@@ -0,0 +1,75 @@
+package xyz.soukup.ecoCraftCore.mines;
+
+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.World;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import xyz.soukup.ecoCraftCore.messages.Messages;
+
+@SuppressWarnings("UnstableApiUsage")
+public class MineCommand {
+
+    public static LiteralArgumentBuilder<CommandSourceStack> createCommand() {
+        LiteralArgumentBuilder<CommandSourceStack> regenerate = Commands.literal("regenerate")
+                .executes(MineCommand::regenerateMines);
+
+        LiteralArgumentBuilder<CommandSourceStack> tp = Commands.literal("tp")
+                .requires(source -> source.getSender() instanceof Player)
+                .executes(MineCommand::teleportToMines);
+
+        return Commands.literal("mine")
+                .then(regenerate)
+                .then(tp);
+    }
+
+    private static int regenerateMines(CommandContext<CommandSourceStack> context) {
+        CommandSender sender = context.getSource().getSender();
+        World world = MineWorldManager.getWorld();
+
+        if (world == null) {
+            Messages.send(sender, "mine.error.no-world");
+            return 0;
+        }
+
+        Messages.send(sender, "mine.regenerating");
+
+        for (Player player : world.getPlayers()) {
+            player.teleport(player.getServer().getWorlds().getFirst().getSpawnLocation());
+            Messages.send(player, "mine.teleported-out");
+        }
+
+        MineWorldManager.recreateWorld(newWorld -> {
+            boolean success = MineManager.regenerate(newWorld);
+            if (success) {
+                Messages.send(sender, "mine.regenerate-complete");
+            } else {
+                Messages.send(sender, "mine.error.regenerate-failed");
+            }
+        });
+        return 1;
+    }
+
+    private static int teleportToMines(CommandContext<CommandSourceStack> context) {
+        Player player = (Player) context.getSource().getSender();
+        World world = MineWorldManager.getWorld();
+
+        if (world == null) {
+            Messages.send(player, "mine.error.no-world");
+            return 0;
+        }
+
+        Location spawn = MineWorldManager.getSpawnLocation();
+        if (spawn == null) {
+            Messages.send(player, "mine.error.no-world");
+            return 0;
+        }
+
+        player.teleport(spawn);
+        Messages.send(player, "mine.teleporting");
+        return 1;
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/mines/MineManager.java

@@ -0,0 +1,62 @@
+package xyz.soukup.ecoCraftCore.mines;
+
+import org.bukkit.Location;
+import org.bukkit.World;
+import xyz.soukup.ecoCraftCore.mines.generation.MineGenerationConfig;
+import xyz.soukup.ecoCraftCore.mines.generation.MineGenerator;
+import xyz.soukup.ecoCraftCore.mines.generation.MineRoomLibrary;
+
+import static xyz.soukup.ecoCraftCore.EcoCraftCore.plugin;
+
+public final class MineManager {
+
+    private MineManager() {
+    }
+
+    public static boolean regenerate(World world) {
+        MineGenerationConfig generationConfig = MineGenerationConfig.fromConfiguration(plugin.getConfig(), world);
+        MineRoomLibrary roomLibrary = MineRoomLibrary.load(
+                plugin.getDataFolder(),
+                generationConfig.roomsDirectory(),
+                plugin.getLogger()
+        );
+
+        if (roomLibrary.isEmpty()) {
+            plugin.getLogger().severe("[MineGen] No valid room prefabs were loaded from: "
+                    + roomLibrary.roomsDirectory().getAbsolutePath());
+            return false;
+        }
+
+        MineGenerator.Result generationResult = new MineGenerator(
+                world,
+                generationConfig,
+                roomLibrary,
+                plugin.getLogger()
+        ).generate();
+
+        if (!generationResult.success()) {
+            return false;
+        }
+
+        Location spawn = getConfiguredSpawnLocation(world);
+        world.setSpawnLocation(spawn);
+
+        plugin.getLogger().info("[MineGen] Mine generated with " + generationResult.roomsPlaced() + " rooms.");
+        return true;
+    }
+
+    public static Location getConfiguredSpawnLocation(World world) {
+        Location fallback = new Location(world, 5.5, world.getMaxHeight() - 9, 5.5, 0f, 0f);
+
+        if (!plugin.getConfig().isConfigurationSection("mine.spawn")) {
+            return fallback;
+        }
+
+        double x = plugin.getConfig().getDouble("mine.spawn.x", fallback.getX());
+        double y = plugin.getConfig().getDouble("mine.spawn.y", fallback.getY());
+        double z = plugin.getConfig().getDouble("mine.spawn.z", fallback.getZ());
+        float yaw = (float) plugin.getConfig().getDouble("mine.spawn.yaw", 0.0);
+        float pitch = (float) plugin.getConfig().getDouble("mine.spawn.pitch", 0.0);
+        return new Location(world, x, y, z, yaw, pitch);
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/mines/MineWorldManager.java

@@ -0,0 +1,230 @@
+package xyz.soukup.ecoCraftCore.mines;
+
+import com.infernalsuite.asp.api.AdvancedSlimePaperAPI;
+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 org.bukkit.GameRule;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockExplodeEvent;
+import org.bukkit.event.entity.EntityExplodeEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerChangedWorldEvent;
+import org.bukkit.event.player.PlayerItemDamageEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import xyz.soukup.ecoCraftCore.database.objects.Island;
+import xyz.soukup.ecoCraftCore.islands.DatabaseIslandLoader;
+
+import java.util.function.Consumer;
+
+import static xyz.soukup.ecoCraftCore.EcoCraftCore.plugin;
+
+public class MineWorldManager implements Listener {
+
+    public static final String MINE_WORLD_NAME = "mine_world";
+    private static World mineWorld;
+
+    public static void init() {
+        AdvancedSlimePaperAPI asp = AdvancedSlimePaperAPI.instance();
+        DatabaseIslandLoader loader = new DatabaseIslandLoader();
+
+        Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
+            try {
+                SlimeWorld slimeWorld = null;
+
+                if (loader.worldExists(MINE_WORLD_NAME)) {
+                    try {
+                        slimeWorld = asp.readWorld(loader, MINE_WORLD_NAME, false, new SlimePropertyMap());
+                    } catch (Exception exception) {
+                        plugin.getLogger().warning("Mine world data is corrupted, recreating...");
+                        loader.deleteWorld(MINE_WORLD_NAME);
+                    }
+                }
+
+                if (slimeWorld == null) {
+                    SlimePropertyMap properties = new SlimePropertyMap();
+                    properties.setValue(SlimeProperties.ENVIRONMENT, "NORMAL");
+
+                    Island island = new Island("mine", MINE_WORLD_NAME, "Mine World", "Shared mine world", "server", "system", null);
+                    island.save();
+
+                    slimeWorld = asp.createEmptyWorld(MINE_WORLD_NAME, false, properties, loader);
+                }
+
+                SlimeWorld finalWorld = slimeWorld;
+                Bukkit.getScheduler().runTask(plugin, () -> {
+                    asp.loadWorld(finalWorld, true);
+                    mineWorld = Bukkit.getWorld(MINE_WORLD_NAME);
+
+                    if (mineWorld != null) {
+                        mineWorld.setGameRule(GameRule.DO_MOB_SPAWNING, false);
+                        mineWorld.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, false);
+                        mineWorld.setGameRule(GameRule.DO_WEATHER_CYCLE, false);
+                        mineWorld.setTime(6000);
+                        if (plugin.getConfig().getBoolean("mine.paste-on-startup", false)) {
+                            MineManager.regenerate(mineWorld);
+                        }
+                        plugin.getLogger().info("Mine world loaded successfully.");
+                    }
+                });
+            } catch (Exception exception) {
+                exception.printStackTrace();
+                plugin.getLogger().severe("Failed to load mine world.");
+            }
+        });
+    }
+
+    public static World getWorld() {
+        return mineWorld;
+    }
+
+    public static Location getSpawnLocation() {
+        if (mineWorld == null) {
+            return null;
+        }
+        return MineManager.getConfiguredSpawnLocation(mineWorld);
+    }
+
+    public static void recreateWorld(Consumer<World> callback) {
+        AdvancedSlimePaperAPI asp = AdvancedSlimePaperAPI.instance();
+        DatabaseIslandLoader loader = new DatabaseIslandLoader();
+
+        plugin.getLogger().info("[MineWorld] Unloading old mine world...");
+
+        if (mineWorld != null) {
+            Bukkit.unloadWorld(mineWorld, false);
+            mineWorld = null;
+        }
+
+        Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
+            try {
+                loader.deleteWorld(MINE_WORLD_NAME);
+                plugin.getLogger().info("[MineWorld] Old mine world metadata deleted.");
+
+                SlimePropertyMap properties = new SlimePropertyMap();
+                properties.setValue(SlimeProperties.ENVIRONMENT, "NORMAL");
+
+                Island island = new Island("mine", MINE_WORLD_NAME, "Mine World", "Shared mine world", "server", "system", null);
+                island.save();
+
+                SlimeWorld slimeWorld = asp.createEmptyWorld(MINE_WORLD_NAME, false, properties, loader);
+
+                Bukkit.getScheduler().runTask(plugin, () -> {
+                    asp.loadWorld(slimeWorld, true);
+                    mineWorld = Bukkit.getWorld(MINE_WORLD_NAME);
+
+                    if (mineWorld != null) {
+                        mineWorld.setGameRule(GameRule.DO_MOB_SPAWNING, false);
+                        mineWorld.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, false);
+                        mineWorld.setGameRule(GameRule.DO_WEATHER_CYCLE, false);
+                        mineWorld.setTime(6000);
+                        plugin.getLogger().info("[MineWorld] Fresh mine world created and loaded.");
+                        callback.accept(mineWorld);
+                    } else {
+                        plugin.getLogger().severe("[MineWorld] Failed to load fresh mine world.");
+                    }
+                });
+            } catch (Exception exception) {
+                exception.printStackTrace();
+                plugin.getLogger().severe("[MineWorld] Failed to recreate mine world.");
+            }
+        });
+    }
+
+    private boolean isInMineWorld(Player player) {
+        return player.getWorld().equals(mineWorld);
+    }
+
+    private boolean isInMineWorld(World world) {
+        return world.equals(mineWorld);
+    }
+
+    @EventHandler
+    public void onWorldChange(PlayerChangedWorldEvent event) {
+        Player player = event.getPlayer();
+
+        if (isInMineWorld(player)) {
+            applyMiningFatigue(player);
+        }
+
+        if (isInMineWorld(event.getFrom())) {
+            player.removePotionEffect(PotionEffectType.MINING_FATIGUE);
+        }
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) {
+        Player player = event.getPlayer();
+        if (isInMineWorld(player)) {
+            applyMiningFatigue(player);
+        }
+    }
+
+    @EventHandler
+    public void onDeath(PlayerDeathEvent event) {
+        Bukkit.getScheduler().runTaskLater(plugin, () -> {
+            Player player = event.getPlayer();
+            if (isInMineWorld(player)) {
+                applyMiningFatigue(player);
+            }
+        }, 1L);
+    }
+
+    private void applyMiningFatigue(Player player) {
+        player.addPotionEffect(new PotionEffect(
+                PotionEffectType.MINING_FATIGUE,
+                Integer.MAX_VALUE,
+                0,
+                true,
+                false,
+                false
+        ));
+    }
+
+    @EventHandler
+    public void onItemDamage(PlayerItemDamageEvent event) {
+        if (!isInMineWorld(event.getPlayer())) {
+            return;
+        }
+        if (event.getItem().getType().getMaxDurability() <= 0) {
+            return;
+        }
+        event.setDamage(event.getDamage() * 2);
+    }
+
+    @EventHandler
+    public void onEntityExplode(EntityExplodeEvent event) {
+        if (!isInMineWorld(event.getEntity().getWorld())) {
+            return;
+        }
+        event.blockList().removeIf(block -> block.getType() == Material.BEDROCK);
+    }
+
+    @EventHandler
+    public void onBlockExplode(BlockExplodeEvent event) {
+        if (!isInMineWorld(event.getBlock().getWorld())) {
+            return;
+        }
+        event.blockList().removeIf(block -> block.getType() == Material.BEDROCK);
+    }
+
+    @EventHandler
+    public void onBlockBreak(BlockBreakEvent event) {
+        if (!isInMineWorld(event.getPlayer())) {
+            return;
+        }
+
+        if (event.getBlock().getType() == Material.BEDROCK) {
+            event.setCancelled(true);
+        }
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/mines/generation/MineBranchState.java

@@ -0,0 +1,50 @@
+package xyz.soukup.ecoCraftCore.mines.generation;
+
+import java.util.Locale;
+
+public record MineBranchState(
+        int branchId,
+        boolean mainPath,
+        int depth,
+        String activeNaturalBiome,
+        int biomeOriginDepth,
+        int naturalBiomeLength
+) {
+
+    public boolean hasActiveNaturalBiome() {
+        return activeNaturalBiome != null && !activeNaturalBiome.isBlank();
+    }
+
+    public MineBranchState withDepth(int newDepth) {
+        return new MineBranchState(
+                branchId,
+                mainPath,
+                newDepth,
+                activeNaturalBiome,
+                biomeOriginDepth,
+                naturalBiomeLength
+        );
+    }
+
+    public MineBranchState clearNaturalBiome() {
+        return new MineBranchState(
+                branchId,
+                mainPath,
+                depth,
+                null,
+                -1,
+                0
+        );
+    }
+
+    public MineBranchState activateNaturalBiome(String biome, int originDepth, int length) {
+        return new MineBranchState(
+                branchId,
+                mainPath,
+                depth,
+                biome == null ? null : biome.toUpperCase(Locale.ROOT),
+                originDepth,
+                Math.max(1, length)
+        );
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/mines/generation/MineDirection.java

@@ -0,0 +1,68 @@
+package xyz.soukup.ecoCraftCore.mines.generation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public enum MineDirection {
+    FRONT(1 << 0, 0, 0, 1),
+    BACK(1 << 1, 0, 0, -1),
+    LEFT(1 << 2, -1, 0, 0),
+    RIGHT(1 << 3, 1, 0, 0),
+    TOP(1 << 4, 0, 1, 0),
+    BOTTOM(1 << 5, 0, -1, 0);
+
+    private static final List<MineDirection> HORIZONTAL_DIRECTIONS = List.of(FRONT, BACK, LEFT, RIGHT);
+
+    private final int bitMask;
+    private final int deltaX;
+    private final int deltaY;
+    private final int deltaZ;
+
+    MineDirection(int bitMask, int deltaX, int deltaY, int deltaZ) {
+        this.bitMask = bitMask;
+        this.deltaX = deltaX;
+        this.deltaY = deltaY;
+        this.deltaZ = deltaZ;
+    }
+
+    public int bitMask() {
+        return bitMask;
+    }
+
+    public int deltaX() {
+        return deltaX;
+    }
+
+    public int deltaY() {
+        return deltaY;
+    }
+
+    public int deltaZ() {
+        return deltaZ;
+    }
+
+    public MineDirection opposite() {
+        return switch (this) {
+            case FRONT -> BACK;
+            case BACK -> FRONT;
+            case LEFT -> RIGHT;
+            case RIGHT -> LEFT;
+            case TOP -> BOTTOM;
+            case BOTTOM -> TOP;
+        };
+    }
+
+    public static List<MineDirection> horizontalDirections() {
+        return HORIZONTAL_DIRECTIONS;
+    }
+
+    public static List<MineDirection> directionsFromMask(int exitsMask) {
+        List<MineDirection> directions = new ArrayList<>();
+        for (MineDirection direction : values()) {
+            if ((exitsMask & direction.bitMask) != 0) {
+                directions.add(direction);
+            }
+        }
+        return directions;
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/mines/generation/MineGenerationConfig.java

@@ -0,0 +1,191 @@
+package xyz.soukup.ecoCraftCore.mines.generation;
+
+import com.sk89q.worldedit.math.BlockVector3;
+import org.bukkit.World;
+import org.bukkit.configuration.file.FileConfiguration;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+public record MineGenerationConfig(
+        String roomsDirectory,
+        String starterRoomId,
+        String defaultBiome,
+        int roomSize,
+        int maxDepth,
+        int maxRooms,
+        boolean ignoreAir,
+        BlockVector3 origin,
+        List<DepthBiomeRule> depthBiomes,
+        List<NaturalBiomeRule> naturalBiomes
+) {
+
+    private static final String BASE_PATH = "mine.generator";
+    private static final Pattern ROOM_IDENTIFIER_PATTERN = Pattern.compile("^[A-Z]{2}\\d+$");
+
+    public static MineGenerationConfig fromConfiguration(FileConfiguration configuration, World world) {
+        String roomsDirectory = configuration.getString(BASE_PATH + ".rooms-directory", "rooms");
+        String starterRoomId = normalizeRoomIdentifier(configuration.getString(BASE_PATH + ".starter-room", "ST15"));
+        String defaultBiome = normalizeBiome(configuration.getString(BASE_PATH + ".default-biome", "ST"), "ST");
+
+        int roomSize = Math.max(1, configuration.getInt(BASE_PATH + ".room-size", 16));
+        int maxDepth = Math.max(1, configuration.getInt(BASE_PATH + ".max-depth", 64));
+        int maxRooms = Math.max(1, configuration.getInt(BASE_PATH + ".max-rooms", 320));
+        boolean ignoreAir = configuration.getBoolean(BASE_PATH + ".ignore-air", false);
+
+        int defaultY = world.getMaxHeight() - 10;
+        BlockVector3 origin = BlockVector3.at(
+                configuration.getInt(BASE_PATH + ".origin.x", 0),
+                configuration.getInt(BASE_PATH + ".origin.y", defaultY),
+                configuration.getInt(BASE_PATH + ".origin.z", 0)
+        );
+
+        List<DepthBiomeRule> depthBiomes = parseDepthBiomes(
+                configuration.getMapList(BASE_PATH + ".depth-biomes"),
+                defaultBiome
+        );
+        List<NaturalBiomeRule> naturalBiomes = parseNaturalBiomes(
+                configuration.getMapList(BASE_PATH + ".natural-biomes")
+        );
+
+        return new MineGenerationConfig(
+                roomsDirectory,
+                starterRoomId,
+                defaultBiome,
+                roomSize,
+                maxDepth,
+                maxRooms,
+                ignoreAir,
+                origin,
+                depthBiomes,
+                naturalBiomes
+        );
+    }
+
+    public String resolveDepthBiome(int depth) {
+        String biome = defaultBiome;
+        for (DepthBiomeRule rule : depthBiomes) {
+            if (depth >= rule.minDepth()) {
+                biome = rule.biome();
+            } else {
+                break;
+            }
+        }
+        return biome;
+    }
+
+    private static List<DepthBiomeRule> parseDepthBiomes(List<Map<?, ?>> entries, String defaultBiome) {
+        List<DepthBiomeRule> rules = new ArrayList<>();
+        for (Map<?, ?> entry : entries) {
+            String biome = normalizeBiome(entry.get("biome"), null);
+            if (biome == null) {
+                continue;
+            }
+            int minDepth = Math.max(0, readInt(entry, "min-depth", 0));
+            rules.add(new DepthBiomeRule(biome, minDepth));
+        }
+
+        if (rules.isEmpty()) {
+            rules.add(new DepthBiomeRule(defaultBiome, 0));
+        }
+
+        rules.sort(Comparator.comparingInt(DepthBiomeRule::minDepth));
+        return List.copyOf(rules);
+    }
+
+    private static List<NaturalBiomeRule> parseNaturalBiomes(List<Map<?, ?>> entries) {
+        List<NaturalBiomeRule> rules = new ArrayList<>();
+        for (Map<?, ?> entry : entries) {
+            String biome = normalizeBiome(entry.get("biome"), null);
+            if (biome == null) {
+                continue;
+            }
+
+            double chance = clamp(readDouble(entry, "chance", 0.0), 0.0, 1.0);
+            if (chance <= 0.0) {
+                continue;
+            }
+
+            int length = Math.max(1, readInt(entry, "length", 1));
+            rules.add(new NaturalBiomeRule(biome, chance, length));
+        }
+
+        return List.copyOf(rules);
+    }
+
+    private static int readInt(Map<?, ?> entry, String key, int fallback) {
+        Object value = entry.get(key);
+        if (value instanceof Number number) {
+            return number.intValue();
+        }
+        if (value instanceof String stringValue) {
+            try {
+                return Integer.parseInt(stringValue);
+            } catch (NumberFormatException ignored) {
+                return fallback;
+            }
+        }
+        return fallback;
+    }
+
+    private static double readDouble(Map<?, ?> entry, String key, double fallback) {
+        Object value = entry.get(key);
+        if (value instanceof Number number) {
+            return number.doubleValue();
+        }
+        if (value instanceof String stringValue) {
+            try {
+                return Double.parseDouble(stringValue);
+            } catch (NumberFormatException ignored) {
+                return fallback;
+            }
+        }
+        return fallback;
+    }
+
+    private static double clamp(double value, double min, double max) {
+        if (value < min) {
+            return min;
+        }
+        if (value > max) {
+            return max;
+        }
+        return value;
+    }
+
+    private static String normalizeRoomIdentifier(String rawValue) {
+        if (rawValue == null || rawValue.isBlank()) {
+            return "ST15";
+        }
+
+        String normalized = rawValue.trim().toUpperCase(Locale.ROOT);
+        int extensionIndex = normalized.indexOf('.');
+        if (extensionIndex > 0) {
+            normalized = normalized.substring(0, extensionIndex);
+        }
+
+        if (!ROOM_IDENTIFIER_PATTERN.matcher(normalized).matches()) {
+            return "ST15";
+        }
+
+        return normalized;
+    }
+
+    private static String normalizeBiome(Object rawValue, String fallback) {
+        if (!(rawValue instanceof String biome) || biome.isBlank()) {
+            return fallback;
+        }
+
+        return biome.trim().toUpperCase(Locale.ROOT);
+    }
+
+    public record DepthBiomeRule(String biome, int minDepth) {
+    }
+
+    public record NaturalBiomeRule(String biome, double chance, int length) {
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/mines/generation/MineGenerationPoint.java

@@ -0,0 +1,9 @@
+package xyz.soukup.ecoCraftCore.mines.generation;
+
+public record MineGenerationPoint(
+        MineGridPosition gridPosition,
+        MineDirection incomingDirection,
+        MineDirection travelDirection,
+        MineBranchState branchState
+) {
+}

src/main/java/xyz/soukup/ecoCraftCore/mines/generation/MineGenerator.java

@@ -0,0 +1,376 @@
+package xyz.soukup.ecoCraftCore.mines.generation;
+
+import com.sk89q.worldedit.EditSession;
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.WorldEditException;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.function.operation.Operation;
+import com.sk89q.worldedit.function.operation.Operations;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.session.ClipboardHolder;
+import org.bukkit.World;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public final class MineGenerator {
+
+    private static final MineGridPosition STARTER_GRID_POSITION = new MineGridPosition(0, 0, 0);
+
+    private final World world;
+    private final MineGenerationConfig config;
+    private final MineRoomLibrary roomLibrary;
+    private final Logger logger;
+    private final Random random;
+
+    private int nextBranchId = 1;
+
+    public MineGenerator(World world, MineGenerationConfig config, MineRoomLibrary roomLibrary, Logger logger) {
+        this.world = world;
+        this.config = config;
+        this.roomLibrary = roomLibrary;
+        this.logger = logger;
+        this.random = ThreadLocalRandom.current();
+    }
+
+    public Result generate() {
+        List<MineRoomPrefab> starterCandidates = roomLibrary.roomsForIdentifier(config.starterRoomId());
+        if (starterCandidates.isEmpty()) {
+            logger.severe("[MineGen] Starter room '" + config.starterRoomId() + "' was not found in room prefabs.");
+            return Result.failure();
+        }
+
+        MineRoomPrefab starterRoom = chooseWeighted(starterCandidates);
+        if (starterRoom == null) {
+            logger.severe("[MineGen] Starter room selection failed.");
+            return Result.failure();
+        }
+
+        if (!hasAllHorizontalExits(starterRoom)) {
+            logger.severe("[MineGen] Starter room '" + starterRoom.sourceFile().getName()
+                    + "' must contain FRONT, BACK, LEFT and RIGHT exits.");
+            return Result.failure();
+        }
+
+        Map<MineGridPosition, MineRoomPrefab> occupiedPositions = new HashMap<>();
+        Deque<MineGenerationPoint> generationQueue = new ArrayDeque<>();
+        int roomsPlaced = 0;
+
+        com.sk89q.worldedit.world.World worldEditWorld = BukkitAdapter.adapt(world);
+        try (EditSession editSession = WorldEdit.getInstance().newEditSession(worldEditWorld)) {
+            pasteRoom(editSession, starterRoom, STARTER_GRID_POSITION);
+            occupiedPositions.put(STARTER_GRID_POSITION, starterRoom);
+            roomsPlaced++;
+
+            for (MineDirection direction : MineDirection.horizontalDirections()) {
+                MineBranchState branchState = new MineBranchState(nextBranchId++, true, 1, null, -1, 0);
+                enqueueNextPoint(generationQueue, STARTER_GRID_POSITION, direction, branchState);
+            }
+
+            while (!generationQueue.isEmpty() && roomsPlaced < config.maxRooms()) {
+                MineGenerationPoint point = generationQueue.poll();
+                MineBranchState branchState = expireNaturalBiomeIfNeeded(point.branchState());
+
+                if (branchState.depth() > config.maxDepth()) {
+                    continue;
+                }
+                if (occupiedPositions.containsKey(point.gridPosition())) {
+                    continue;
+                }
+
+                MineBranchState placementState = maybeActivateNaturalBiome(branchState);
+                String resolvedBiome = resolveBiome(placementState);
+
+                MineRoomPrefab selectedRoom = selectRoom(
+                        point,
+                        placementState,
+                        resolvedBiome,
+                        occupiedPositions
+                );
+                if (selectedRoom == null) {
+                    continue;
+                }
+
+                pasteRoom(editSession, selectedRoom, point.gridPosition());
+                occupiedPositions.put(point.gridPosition(), selectedRoom);
+                roomsPlaced++;
+
+                enqueueFollowingPoints(
+                        generationQueue,
+                        point,
+                        placementState,
+                        selectedRoom
+                );
+            }
+        } catch (WorldEditException exception) {
+            logger.log(Level.SEVERE, "[MineGen] Failed to generate mine layout.", exception);
+            return Result.failure();
+        }
+
+        return new Result(true, roomsPlaced);
+    }
+
+    private String resolveBiome(MineBranchState branchState) {
+        if (branchState.hasActiveNaturalBiome()) {
+            return branchState.activeNaturalBiome();
+        }
+        return config.resolveDepthBiome(branchState.depth());
+    }
+
+    private MineRoomPrefab selectRoom(
+            MineGenerationPoint point,
+            MineBranchState branchState,
+            String biome,
+            Map<MineGridPosition, MineRoomPrefab> occupiedPositions
+    ) {
+        List<MineRoomPrefab> candidates = collectCandidateRooms(
+                point,
+                branchState,
+                biome,
+                occupiedPositions,
+                true
+        );
+
+        if (candidates.isEmpty()) {
+            candidates = collectCandidateRooms(
+                    point,
+                    branchState,
+                    biome,
+                    occupiedPositions,
+                    false
+            );
+        }
+
+        if (candidates.isEmpty()) {
+            return null;
+        }
+
+        return chooseWeighted(candidates);
+    }
+
+    private List<MineRoomPrefab> collectCandidateRooms(
+            MineGenerationPoint point,
+            MineBranchState branchState,
+            String biome,
+            Map<MineGridPosition, MineRoomPrefab> occupiedPositions,
+            boolean avoidOccupiedExitTargets
+    ) {
+        int blockedExitMask = buildBlockedExitMask(point.gridPosition(), point.incomingDirection(), occupiedPositions);
+
+        List<MineRoomPrefab> candidates = new ArrayList<>();
+        for (MineRoomPrefab room : roomLibrary.allRooms()) {
+            if (!room.biome().equalsIgnoreCase(biome)) {
+                continue;
+            }
+            if (!room.hasExit(point.incomingDirection())) {
+                continue;
+            }
+            if (!matchesBranchConstraints(room, branchState.mainPath())) {
+                continue;
+            }
+            if (avoidOccupiedExitTargets && (room.exitsMask() & blockedExitMask) != 0) {
+                continue;
+            }
+            candidates.add(room);
+        }
+
+        return candidates;
+    }
+
+    private boolean matchesBranchConstraints(MineRoomPrefab room, boolean mainPath) {
+        int exitCount = room.exitCount();
+        if (mainPath) {
+            return exitCount >= 2;
+        }
+        return exitCount == 2;
+    }
+
+    private int buildBlockedExitMask(
+            MineGridPosition targetPosition,
+            MineDirection incomingDirection,
+            Map<MineGridPosition, MineRoomPrefab> occupiedPositions
+    ) {
+        int blockedMask = 0;
+        for (MineDirection direction : MineDirection.values()) {
+            if (direction == incomingDirection) {
+                continue;
+            }
+            if (occupiedPositions.containsKey(targetPosition.offset(direction))) {
+                blockedMask |= direction.bitMask();
+            }
+        }
+        return blockedMask;
+    }
+
+    private void enqueueFollowingPoints(
+            Deque<MineGenerationPoint> generationQueue,
+            MineGenerationPoint point,
+            MineBranchState placementState,
+            MineRoomPrefab room
+    ) {
+        List<MineDirection> outgoingDirections = room.exits().stream()
+                .filter(direction -> direction != point.incomingDirection())
+                .toList();
+
+        if (outgoingDirections.isEmpty()) {
+            return;
+        }
+
+        MineDirection continuationDirection = chooseContinuationDirection(outgoingDirections, point.travelDirection());
+        MineBranchState continuationState = placementState.withDepth(placementState.depth() + 1);
+        enqueueNextPoint(generationQueue, point.gridPosition(), continuationDirection, continuationState);
+
+        if (!placementState.mainPath()) {
+            return;
+        }
+
+        for (MineDirection direction : outgoingDirections) {
+            if (direction == continuationDirection) {
+                continue;
+            }
+
+            MineBranchState childBranchState = new MineBranchState(
+                    nextBranchId++,
+                    false,
+                    placementState.depth() + 1,
+                    placementState.activeNaturalBiome(),
+                    placementState.biomeOriginDepth(),
+                    placementState.naturalBiomeLength()
+            );
+            enqueueNextPoint(generationQueue, point.gridPosition(), direction, childBranchState);
+        }
+    }
+
+    private MineDirection chooseContinuationDirection(List<MineDirection> outgoingDirections, MineDirection preferredDirection) {
+        if (outgoingDirections.contains(preferredDirection)) {
+            return preferredDirection;
+        }
+        return outgoingDirections.get(random.nextInt(outgoingDirections.size()));
+    }
+
+    private MineBranchState expireNaturalBiomeIfNeeded(MineBranchState branchState) {
+        if (!branchState.hasActiveNaturalBiome()) {
+            return branchState;
+        }
+
+        int roomsSpentInBiome = branchState.depth() - branchState.biomeOriginDepth();
+        if (roomsSpentInBiome >= branchState.naturalBiomeLength()) {
+            return branchState.clearNaturalBiome();
+        }
+        return branchState;
+    }
+
+    private MineBranchState maybeActivateNaturalBiome(MineBranchState branchState) {
+        if (branchState.hasActiveNaturalBiome()) {
+            return branchState;
+        }
+        if (config.naturalBiomes().isEmpty()) {
+            return branchState;
+        }
+
+        double totalChance = 0.0;
+        for (MineGenerationConfig.NaturalBiomeRule rule : config.naturalBiomes()) {
+            totalChance += rule.chance();
+        }
+
+        if (totalChance <= 0.0) {
+            return branchState;
+        }
+
+        if (random.nextDouble() > Math.min(1.0, totalChance)) {
+            return branchState;
+        }
+
+        double selectionRoll = random.nextDouble(totalChance);
+        double cumulativeChance = 0.0;
+        for (MineGenerationConfig.NaturalBiomeRule rule : config.naturalBiomes()) {
+            cumulativeChance += rule.chance();
+            if (selectionRoll <= cumulativeChance) {
+                return branchState.activateNaturalBiome(rule.biome(), branchState.depth(), rule.length());
+            }
+        }
+
+        return branchState;
+    }
+
+    private boolean hasAllHorizontalExits(MineRoomPrefab room) {
+        for (MineDirection direction : MineDirection.horizontalDirections()) {
+            if (!room.hasExit(direction)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static void enqueueNextPoint(
+            Deque<MineGenerationPoint> generationQueue,
+            MineGridPosition currentPosition,
+            MineDirection outgoingDirection,
+            MineBranchState branchState
+    ) {
+        generationQueue.add(new MineGenerationPoint(
+                currentPosition.offset(outgoingDirection),
+                outgoingDirection.opposite(),
+                outgoingDirection,
+                branchState
+        ));
+    }
+
+    private MineRoomPrefab chooseWeighted(List<MineRoomPrefab> rooms) {
+        if (rooms.isEmpty()) {
+            return null;
+        }
+        if (rooms.size() == 1) {
+            return rooms.getFirst();
+        }
+
+        int totalWeight = 0;
+        for (MineRoomPrefab room : rooms) {
+            totalWeight += Math.max(1, room.weight());
+        }
+
+        int roll = random.nextInt(totalWeight);
+        int runningWeight = 0;
+        for (MineRoomPrefab room : rooms) {
+            runningWeight += Math.max(1, room.weight());
+            if (roll < runningWeight) {
+                return room;
+            }
+        }
+
+        return rooms.getLast();
+    }
+
+    private void pasteRoom(EditSession editSession, MineRoomPrefab room, MineGridPosition gridPosition) throws WorldEditException {
+        BlockVector3 target = toWorldPosition(gridPosition);
+        Operation operation = new ClipboardHolder(room.clipboard())
+                .createPaste(editSession)
+                .to(target)
+                .ignoreAirBlocks(config.ignoreAir())
+                .build();
+        Operations.complete(operation);
+    }
+
+    private BlockVector3 toWorldPosition(MineGridPosition gridPosition) {
+        return config.origin().add(
+                gridPosition.x() * config.roomSize(),
+                gridPosition.y() * config.roomSize(),
+                gridPosition.z() * config.roomSize()
+        );
+    }
+
+    public record Result(boolean success, int roomsPlaced) {
+
+        public static Result failure() {
+            return new Result(false, 0);
+        }
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/mines/generation/MineGridPosition.java

@@ -0,0 +1,12 @@
+package xyz.soukup.ecoCraftCore.mines.generation;
+
+public record MineGridPosition(int x, int y, int z) {
+
+    public MineGridPosition offset(MineDirection direction) {
+        return new MineGridPosition(
+                x + direction.deltaX(),
+                y + direction.deltaY(),
+                z + direction.deltaZ()
+        );
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/mines/generation/MineRoomLibrary.java

@@ -0,0 +1,181 @@
+package xyz.soukup.ecoCraftCore.mines.generation;
+
+import com.sk89q.worldedit.extent.clipboard.Clipboard;
+import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormat;
+import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormats;
+import com.sk89q.worldedit.extent.clipboard.io.ClipboardReader;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+public final class MineRoomLibrary {
+
+    private static final Pattern ROOM_FILE_PATTERN = Pattern.compile("^([A-Za-z]{2})(\\d+)(?:_(\\d+))?$");
+
+    private final File roomsDirectory;
+    private final List<MineRoomPrefab> prefabs;
+    private final Map<String, List<MineRoomPrefab>> prefabsByIdentifier;
+
+    private MineRoomLibrary(
+            File roomsDirectory,
+            List<MineRoomPrefab> prefabs,
+            Map<String, List<MineRoomPrefab>> prefabsByIdentifier
+    ) {
+        this.roomsDirectory = roomsDirectory;
+        this.prefabs = prefabs;
+        this.prefabsByIdentifier = prefabsByIdentifier;
+    }
+
+    public static MineRoomLibrary load(File dataFolder, String roomsDirectoryName, Logger logger) {
+        String safeDirectoryName = roomsDirectoryName == null || roomsDirectoryName.isBlank()
+                ? "rooms"
+                : roomsDirectoryName;
+
+        File roomsDirectory = new File(dataFolder, safeDirectoryName);
+        if (!roomsDirectory.exists() && !roomsDirectory.mkdirs()) {
+            logger.warning("[MineGen] Could not create room prefab directory: " + roomsDirectory.getAbsolutePath());
+        }
+
+        File[] roomFiles = roomsDirectory.listFiles(MineRoomLibrary::isSupportedRoomFile);
+        if (roomFiles == null || roomFiles.length == 0) {
+            return new MineRoomLibrary(roomsDirectory, List.of(), Map.of());
+        }
+
+        List<MineRoomPrefab> prefabs = new ArrayList<>();
+        Map<String, List<MineRoomPrefab>> prefabsByIdentifier = new HashMap<>();
+
+        for (File roomFile : roomFiles) {
+            RoomFileMetadata metadata = parseMetadata(roomFile.getName(), logger);
+            if (metadata == null) {
+                continue;
+            }
+
+            ClipboardFormat format = ClipboardFormats.findByFile(roomFile);
+            if (format == null) {
+                logger.warning("[MineGen] Unsupported room format: " + roomFile.getName());
+                continue;
+            }
+
+            try (
+                    FileInputStream inputStream = new FileInputStream(roomFile);
+                    ClipboardReader reader = format.getReader(inputStream)
+            ) {
+                Clipboard clipboard = reader.read();
+                MineRoomPrefab prefab = new MineRoomPrefab(
+                        metadata.identifier(),
+                        metadata.biome(),
+                        metadata.exitsMask(),
+                        metadata.weight(),
+                        roomFile,
+                        clipboard
+                );
+                prefabs.add(prefab);
+                prefabsByIdentifier.computeIfAbsent(metadata.identifier(), ignored -> new ArrayList<>()).add(prefab);
+            } catch (IOException exception) {
+                logger.warning("[MineGen] Failed to load room prefab " + roomFile.getName()
+                        + ": " + exception.getMessage());
+            }
+        }
+
+        return new MineRoomLibrary(
+                roomsDirectory,
+                List.copyOf(prefabs),
+                prefabsByIdentifier.entrySet().stream()
+                        .collect(Collectors.toUnmodifiableMap(
+                                Map.Entry::getKey,
+                                entry -> List.copyOf(entry.getValue())
+                        ))
+        );
+    }
+
+    public File roomsDirectory() {
+        return roomsDirectory;
+    }
+
+    public boolean isEmpty() {
+        return prefabs.isEmpty();
+    }
+
+    public List<MineRoomPrefab> allRooms() {
+        return prefabs;
+    }
+
+    public List<MineRoomPrefab> roomsForIdentifier(String identifier) {
+        if (identifier == null) {
+            return List.of();
+        }
+
+        return prefabsByIdentifier.getOrDefault(identifier.toUpperCase(Locale.ROOT), List.of());
+    }
+
+    private static boolean isSupportedRoomFile(File file) {
+        if (!file.isFile()) {
+            return false;
+        }
+
+        String lowerName = file.getName().toLowerCase(Locale.ROOT);
+        return lowerName.endsWith(".schematic") || lowerName.endsWith(".schem");
+    }
+
+    private static RoomFileMetadata parseMetadata(String fileName, Logger logger) {
+        int extensionIndex = fileName.lastIndexOf('.');
+        if (extensionIndex <= 0) {
+            logger.warning("[MineGen] Ignoring room prefab '" + fileName + "': missing file extension.");
+            return null;
+        }
+
+        String baseName = fileName.substring(0, extensionIndex);
+        Matcher matcher = ROOM_FILE_PATTERN.matcher(baseName);
+        if (!matcher.matches()) {
+            logger.warning("[MineGen] Ignoring room prefab '" + fileName
+                    + "': expected format <room_biome><room_exits>_<room_weight>.");
+            return null;
+        }
+
+        String biome = matcher.group(1).toUpperCase(Locale.ROOT);
+        int exitsMask;
+        try {
+            exitsMask = Integer.parseInt(matcher.group(2));
+        } catch (NumberFormatException exception) {
+            logger.warning("[MineGen] Ignoring room prefab '" + fileName + "': invalid exits value.");
+            return null;
+        }
+
+        if (exitsMask <= 0 || exitsMask > 63) {
+            logger.warning("[MineGen] Ignoring room prefab '" + fileName
+                    + "': exits bitmask must be in range 1..63.");
+            return null;
+        }
+
+        int weight = 1;
+        String weightGroup = matcher.group(3);
+        if (weightGroup != null) {
+            try {
+                weight = Integer.parseInt(weightGroup);
+                if (weight <= 0) {
+                    logger.warning("[MineGen] Room prefab '" + fileName + "' has non-positive weight, using 1.");
+                    weight = 1;
+                }
+            } catch (NumberFormatException exception) {
+                logger.warning("[MineGen] Room prefab '" + fileName + "' has invalid weight, using 1.");
+                weight = 1;
+            }
+        }
+
+        String identifier = biome + exitsMask;
+        return new RoomFileMetadata(identifier, biome, exitsMask, weight);
+    }
+
+    private record RoomFileMetadata(String identifier, String biome, int exitsMask, int weight) {
+    }
+}

src/main/java/xyz/soukup/ecoCraftCore/mines/generation/MineRoomPrefab.java

@@ -0,0 +1,28 @@
+package xyz.soukup.ecoCraftCore.mines.generation;
+
+import com.sk89q.worldedit.extent.clipboard.Clipboard;
+
+import java.io.File;
+import java.util.List;
+
+public record MineRoomPrefab(
+        String identifier,
+        String biome,
+        int exitsMask,
+        int weight,
+        File sourceFile,
+        Clipboard clipboard
+) {
+
+    public boolean hasExit(MineDirection direction) {
+        return (exitsMask & direction.bitMask()) != 0;
+    }
+
+    public int exitCount() {
+        return Integer.bitCount(exitsMask);
+    }
+
+    public List<MineDirection> exits() {
+        return MineDirection.directionsFromMask(exitsMask);
+    }
+}

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,97 @@
+package xyz.soukup.ecoCraftCore.regions;
+
+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.command.CommandSender;
+import org.bukkit.entity.Player;
+import xyz.soukup.ecoCraftCore.database.DaoRegistry;
+import xyz.soukup.ecoCraftCore.database.objects.Region;
+import xyz.soukup.ecoCraftCore.messages.Messages;
+
+import java.sql.SQLException;
+import java.util.List;
+
+import static xyz.soukup.ecoCraftCore.EcoCraftCore.plugin;
+
+public class RegionAdminCommand {
+    public static LiteralArgumentBuilder<CommandSourceStack> getCommand() {
+        LiteralArgumentBuilder<CommandSourceStack> create = Commands.literal("create")
+                .then(Commands.argument("type", IntegerArgumentType.integer(0, 1))
+                        .executes(RegionAdminCommand::createRegion));
+
+        LiteralArgumentBuilder<CommandSourceStack> addMember = Commands.literal("addMember")
+                .then(Commands.argument("id", IntegerArgumentType.integer())
+                        .suggests((context, builder) -> {
+                            try {
+                                QueryBuilder<Region, Integer> queryBuilder = DaoRegistry.getRegionDao().queryBuilder();
+                                queryBuilder.selectColumns("id");
+                                List<Region> regions = queryBuilder.query();
+                                for (Region region : regions) {
+                                    builder.suggest(region.getId());
+                                }
+                                return builder.buildFuture();
+                            } catch (SQLException e) {
+                                throw new RuntimeException(e);
+                            }
+                        })
+                        .then(Commands.argument("player", StringArgumentType.word())
+                                .suggests((context, builder) -> {
+                                    for (Player onlinePlayer : plugin.getServer().getOnlinePlayers()) {
+                                        builder.suggest(onlinePlayer.getName());
+                                    }
+                                    return builder.buildFuture();
+                                })
+                                .then(Commands.argument("membership", StringArgumentType.word())
+                                        .suggests(((context, builder) -> {
+                                            builder.suggest("owner");
+                                            builder.suggest("editor");
+                                            builder.suggest("member");
+                                            return builder.buildFuture();
+                                        }))
+                                        .executes(RegionAdminCommand::addMember))));
+
+
+        return Commands.literal("region")
+                .then(create)
+                .then(addMember);
+    }
+
+    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;
+    }
+
+    private static int addMember(CommandContext<CommandSourceStack> context) {
+        Integer id = context.getArgument("id", Integer.class);
+        String player = context.getArgument("player", String.class);
+        String membership = context.getArgument("membership", String.class);
+        CommandSender commandSender = context.getSource().getSender();
+
+        int status = RegionManager.addMember(id, "player", player, membership);
+        switch (status){
+            case 0 -> Messages.send(commandSender, "generic.success.created");
+            case 1 -> Messages.send(commandSender, "region.error.not-exist");
+        }
+        return 0;
+    }
+
+
+}

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

@@ -0,0 +1,319 @@
+package xyz.soukup.ecoCraftCore.regions;
+
+import org.bukkit.Location;
+import org.bukkit.NamespacedKey;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.Minecart;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.inventory.InventoryPickupItemEvent;
+import org.bukkit.event.player.*;
+import org.bukkit.event.vehicle.VehicleDestroyEvent;
+import org.bukkit.event.vehicle.VehicleEntityCollisionEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.persistence.PersistentDataType;
+import xyz.soukup.ecoCraftCore.database.objects.Region;
+import xyz.soukup.ecoCraftCore.database.objects.RegionMember;
+
+import static xyz.soukup.ecoCraftCore.EcoCraftCore.plugin;
+
+public class RegionEvents implements Listener {
+
+    @EventHandler
+    public void onPlayerInteract(PlayerInteractEvent event){
+        switch (event.getAction()) {
+            case RIGHT_CLICK_BLOCK:
+            case LEFT_CLICK_BLOCK:
+                break;
+            default:
+                return;
+        }
+
+
+        Block block = event.getClickedBlock();
+        ItemStack item = event.getItem();
+        if (block == null) return;
+
+        if (item != null && item.getType().isBlock() && !block.getType().isInteractable()) {
+            return;
+        }
+
+        boolean allowed = isAllowedToInteract(
+                block.getWorld().getName(),
+                event.getPlayer(),
+                block.getX(),
+                block.getY(),
+                block.getZ()
+        );
+
+        if (allowed){
+            return;
+        }
+
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void  onPlayerInteractPhysical(PlayerInteractEvent event){
+        if (!event.getAction().equals(Action.PHYSICAL)){
+            return;
+        }
+
+        Player player = event.getPlayer();
+        Location location = player.getLocation();
+
+        boolean allowed = isAllowedToInteract(
+                location.getWorld().getName(),
+                player,
+                location.getBlockX(),
+                location.getBlockY(),
+                location.getBlockZ()
+        );
+
+        if (allowed){
+            return;
+        }
+
+        event.setCancelled(true);
+
+    }
+
+    @EventHandler
+    public void onBlockPlace(BlockPlaceEvent event) {
+        Block block = event.getBlockPlaced();
+
+        boolean allowed = isAllowedToInteract(
+                block.getWorld().getName(),
+                event.getPlayer(),
+                block.getX(),
+                block.getY(),
+                block.getZ()
+        );
+
+        if (allowed){
+            return;
+        }
+
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onBlockBreak(BlockBreakEvent event) {
+
+        Block block = event.getBlock();
+
+        boolean allowed = isAllowedToInteract(
+                block.getWorld().getName(),
+                event.getPlayer(),
+                block.getX(),
+                block.getY(),
+                block.getZ()
+        );
+
+        if (allowed){
+            return;
+        }
+
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onBucketUse(PlayerBucketEmptyEvent event) {
+        Block clickedBlock = event.getBlockClicked();
+
+        boolean allowed = isAllowedToInteract(
+                clickedBlock.getWorld().getName(),
+                event.getPlayer(),
+                clickedBlock.getX(),
+                clickedBlock.getY(),
+                clickedBlock.getZ()
+        );
+
+        if (allowed){
+            return;
+        }
+
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onBucketUse(PlayerBucketFillEvent event) {
+        Block clickedBlock = event.getBlockClicked();
+
+        boolean allowed = isAllowedToInteract(
+                clickedBlock.getWorld().getName(),
+                event.getPlayer(),
+                clickedBlock.getX(),
+                clickedBlock.getY(),
+                clickedBlock.getZ()
+        );
+
+        if (allowed){
+            return;
+        }
+
+        event.setCancelled(true);
+    }
+    
+    @EventHandler
+    public void onEntityInteract(PlayerInteractEntityEvent event){
+        Entity entity = event.getRightClicked();
+        Location location = entity.getLocation();
+
+
+        boolean allowed = isAllowedToInteract(
+                location.getWorld().getName(),
+                event.getPlayer(),
+                location.getBlockX(),
+                location.getBlockY(),
+                location.getBlockZ());
+
+        if (allowed){
+            return;
+        }
+
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onEntityHit(EntityDamageByEntityEvent event){
+
+        if (!(event.getDamager() instanceof Player player)){
+            return;
+        }
+
+        Entity entity = event.getEntity();
+        Location location = entity.getLocation();
+
+        boolean allowed = isAllowedToInteract(
+                location.getWorld().getName(),
+                player,
+                location.getBlockX(),
+                location.getBlockY(),
+                location.getBlockZ());
+
+        if (allowed){
+            return;
+        }
+
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onMinecartPush(VehicleEntityCollisionEvent event) {
+
+
+        if (!(event.getEntity() instanceof Player player)){
+            return;
+        }
+
+        Location location = event.getVehicle().getLocation();
+
+        boolean allowed = isAllowedToInteract(
+                location.getWorld().getName(),
+                player,
+                location.getBlockX(),
+                location.getBlockY(),
+                location.getBlockZ());
+
+        if (allowed){
+            return;
+        }
+
+        event.setCancelled(true);
+    }
+
+    //Preventing hopper interaction :P
+    @EventHandler
+    public void onDrop(PlayerDropItemEvent event) {
+        Player player = event.getPlayer();
+        Location location = player.getLocation();
+
+        boolean allowed = isAllowedToInteract(
+                location.getWorld().getName(),
+                player,
+                location.getBlockX(),
+                location.getBlockY(),
+                location.getBlockZ());
+
+        if (allowed){
+            return;
+        }
+
+        Item item = event.getItemDrop();
+
+        item.getPersistentDataContainer().set(new NamespacedKey(plugin, "hopper_stopper"), PersistentDataType.BYTE, (byte) 1);
+
+    }
+
+    @EventHandler
+    public void onHopperPickup(InventoryPickupItemEvent event) {
+        Item item = event.getItem();
+
+        if (!item.getPersistentDataContainer().has(new NamespacedKey(plugin, "hopper_stopper"), PersistentDataType.BYTE)) {
+            return;
+        }
+
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onVehicleDestroy(VehicleDestroyEvent event) {
+        if (!(event.getAttacker() instanceof Player player)){
+            return;
+        }
+
+        Location location = event.getVehicle().getLocation();
+
+        boolean allowed = isAllowedToInteract(
+                location.getWorld().getName(),
+                player,
+                location.getBlockX(),
+                location.getBlockY(),
+                location.getBlockZ());
+
+        if (allowed){
+            return;
+        }
+
+        event.setCancelled(true);
+    }
+
+
+
+    private boolean isAllowedToInteract(String island, Player player, Location location){
+        return isAllowedToInteract(island, player, location.getBlockX(), location.getBlockY(), location.getBlockZ());
+    }
+
+    private boolean isAllowedToInteract(String island, Player player, int x, int y, int z){
+        if (player.isOp()){
+            return true;
+        }
+
+        Region region = Region.findRegion(x, y, z, 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,77 @@
+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.database.objects.RegionMember;
+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.getBlockY();
+        int z1 = primaryLocation.getBlockZ();
+        int x2 = secondaryLocation.getBlockX();
+        int y2 = secondaryLocation.getBlockY();
+        int z2 = secondaryLocation.getBlockZ();
+
+        Region region = new Region(worldName, type, x1, y1, z1, x2, y2, z2);
+        region.save();
+
+        region.addRegionMember(ownerType, owner, "owner");
+
+        return 0;
+    }
+
+    public static int addMember(int id, String memberType, String member, String membershipType){
+        Region region = Region.findById(id);
+
+        if (region == null){
+            return 1;
+        }
+
+        region.addRegionMember(memberType, member, membershipType);
+
+        return 0;
+    }
+
+    public static boolean isAllowedToInteract(Player player, Location location){
+        if (player.isOp()){
+            return true;
+        }
+
+        int x = location.getBlockX();
+        int y = location.getBlockY();
+        int z = location.getBlockZ();
+        String island = location.getWorld().getName();
+
+        Region region = Region.findRegion(x, y, z, 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/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.database.objects.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/shop/ShopLogic.java

@@ -1,6 +1,8 @@
 package xyz.soukup.ecoCraftCore.shop;
 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.StaticPane;
 import io.papermc.paper.dialog.Dialog;
 import io.papermc.paper.dialog.DialogResponseView;
@@ -11,13 +13,16 @@ import io.papermc.paper.registry.data.dialog.input.DialogInput;
 import io.papermc.paper.registry.data.dialog.type.DialogType;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.event.ClickCallback;
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
 import org.bukkit.block.Sign;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockBreakEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
@@ -29,7 +34,7 @@ import xyz.soukup.ecoCraftCore.messages.Messages;
 import xyz.soukup.ecoCraftCore.database.objects.Account;
 import xyz.soukup.ecoCraftCore.database.objects.Shop;
 import xyz.soukup.ecoCraftCore.database.objects.Transaction;
-import xyz.soukup.ecoCraftCore.inventory.VirtualChest;
+import xyz.soukup.ecoCraftCore.database.objects.VirtualChest;
 import xyz.soukup.ecoCraftCore.utilities.*;
 
 import java.util.HashMap;
@@ -87,6 +92,39 @@ public class ShopLogic implements Listener {
         gui.show(player);
 
 
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onDestroy(BlockBreakEvent event){
+
+        if (event.isCancelled()){
+            return;
+        }
+
+        Block block = event.getBlock();
+
+        if (!(block.getState() instanceof Sign sign)){
+            return;
+        }
+
+        Integer id = PDC.getInteger(sign, "shop");
+
+        if (id == null){
+            return;
+        }
+
+        Shop shop = Shop.findById(id);
+
+        if (shop == null){
+            return;
+        }
+
+        event.setCancelled(true);
+        Player player = event.getPlayer();
+        HopperGui gui = confirmBreakGui(block, shop);
+        gui.show(player);
+
+
     }
 
     public static ChestGui buildShopGui(Player player, Shop shop){
@@ -260,7 +298,7 @@ public class ShopLogic implements Listener {
         HashMap<String, String> hashMap = new HashMap<>();
         hashMap.put("count", Integer.toString(amount));
         hashMap.put("price", String.format("%.2f", price));
-        hashMap.put("item", itemStack.displayName().toString());
+        hashMap.put("item", PlainTextComponentSerializer.plainText().serialize(itemStack.displayName()));
 
         Messages.send(player, "shop.buy", hashMap);
 
@@ -348,9 +386,48 @@ public class ShopLogic implements Listener {
         HashMap<String, String> hashMap = new HashMap<>();
         hashMap.put("count", Integer.toString(amount));
         hashMap.put("price", String.format("%.2f", price));
-        hashMap.put("item", itemStack.displayName().toString());
+        hashMap.put("item", PlainTextComponentSerializer.plainText().serialize(itemStack.displayName()));
 
         Messages.send(player, "shop.sell", hashMap);
 
     }
+
+    public static HopperGui confirmBreakGui(Block block, Shop shop){
+        HopperGui gui = new HopperGui(Messages.getAsString("menu.destroy-confirmation.title"));
+        OutlinePane pane = new OutlinePane(0,0, 5, 1);
+
+        gui.setOnGlobalClick(inventoryClickEvent -> {
+            inventoryClickEvent.setCancelled(true);
+        });
+
+        GuiItem confirmButton = new GuiItemBuilder(Material.LIME_WOOL)
+                .setName(Messages.get("menu.destroy-confirmation.confirm"))
+                .build();
+
+        GuiItem cancelButton = new GuiItemBuilder(Material.RED_WOOL)
+                .setName(Messages.get("menu.destroy-confirmation.cancel"))
+                .build();
+
+        cancelButton.setAction(event -> {
+            event.getClickedInventory().close();
+        });
+
+        confirmButton.setAction(event -> {
+            destroyShopAndBlock(block, shop);
+            event.getClickedInventory().close();
+        });
+
+        pane.addItem(confirmButton);
+        pane.addItem(cancelButton);
+
+        gui.getSlotsComponent().addPane(pane);
+
+
+        return gui;
+    }
+
+    private static void destroyShopAndBlock(Block block, Shop shop){
+        block.breakNaturally();
+        shop.delete();
+    }
 }

src/main/java/xyz/soukup/ecoCraftCore/sign/SignEditCommand.java

@@ -0,0 +1,187 @@
+package xyz.soukup.ecoCraftCore.sign;
+
+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 io.papermc.paper.dialog.Dialog;
+import io.papermc.paper.dialog.DialogResponseView;
+import io.papermc.paper.registry.data.dialog.ActionButton;
+import io.papermc.paper.registry.data.dialog.DialogBase;
+import io.papermc.paper.registry.data.dialog.action.DialogAction;
+import io.papermc.paper.registry.data.dialog.input.DialogInput;
+import io.papermc.paper.registry.data.dialog.type.DialogType;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.event.ClickCallback;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.Sign;
+import org.bukkit.block.sign.Side;
+import org.bukkit.block.sign.SignSide;
+import org.bukkit.entity.Player;
+import org.bukkit.persistence.PersistentDataType;
+import xyz.soukup.ecoCraftCore.database.objects.Shop;
+import xyz.soukup.ecoCraftCore.messages.Messages;
+import xyz.soukup.ecoCraftCore.regions.RegionManager;
+import xyz.soukup.ecoCraftCore.utilities.PDC;
+
+import javax.sound.sampled.Line;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+
+public class SignEditCommand {
+
+    private static final HashMap<Player, List<String>> clipBoard = new HashMap<>();
+
+    public static LiteralArgumentBuilder<CommandSourceStack> getCommand(){
+        return Commands.literal("edit-sign")
+                .requires(source -> source.getSender() instanceof Player)
+                .executes(SignEditCommand::openEditMenu);
+    }
+
+    private static int openEditMenu(CommandContext<CommandSourceStack> context){
+        Player player = (Player) context.getSource().getSender();
+        Block block = player.getTargetBlock(null, 10);
+        BlockState blockState = block.getState();
+
+        if (!(blockState instanceof Sign sign)){
+            Messages.send(player, "sign-edit.error.not-sign");
+            return 1;
+        }
+
+        Location location = sign.getLocation();
+
+        if (!RegionManager.isAllowedToInteract(player, location)){
+            Messages.send(player, "region.error.not-allowed-to-interact");
+            return 1;
+        }
+
+        Dialog dialog  = buildEditDialog(sign, player, null);
+        player.showDialog(dialog);
+
+
+
+        return 0;
+    }
+
+
+    public static Dialog buildEditDialog(Sign sign, Player player, List<String> lines){
+
+        if (lines == null){
+            lines = getLines(sign);
+        }
+
+        List<ActionButton> actionButtons = new ArrayList<>();
+
+
+
+        actionButtons.add(ActionButton.builder(Messages.get("gui.sign-edit.buttons.copy"))
+                .action(DialogAction.customClick((view, audience) -> copySignText(view, player, sign), ClickCallback.Options.builder().build()))
+                .build());
+        actionButtons.add(ActionButton.builder(Messages.get("gui.sign-edit.buttons.paste"))
+                .action(DialogAction.customClick((view, audience) -> pasteSignText(sign, player), ClickCallback.Options.builder().build()))
+                .build());
+        actionButtons.add(ActionButton.builder(Messages.get("gui.sign-edit.buttons.confirm"))
+                .action(DialogAction.customClick((view, audience) -> editSign(view, sign, player), ClickCallback.Options.builder().build()))
+                .build());
+        actionButtons.add(ActionButton.builder(Messages.get("gui.sign-edit.buttons.cancel"))
+                .action(DialogAction.customClick((view, audience) -> audience.closeDialog(), ClickCallback.Options.builder().build()))
+                .build());
+
+
+        List<String> finalLines = lines;
+
+        return Dialog.create(builder -> builder.empty()
+                .base(DialogBase.builder(Messages.get("gui.sign-edit.title"))
+                        .inputs(List.of(
+                                DialogInput.text("line1", Messages.get("gui.sign-edit.inputs.line1"))
+                                        .initial(finalLines.getFirst())
+                                        .maxLength(256)
+                                        .build(),
+                                DialogInput.text("line2", Messages.get("gui.sign-edit.inputs.line2"))
+                                        .initial(finalLines.get(1))
+                                        .maxLength(256)
+                                        .build(),
+                                DialogInput.text("line3", Messages.get("gui.sign-edit.inputs.line3"))
+                                        .initial(finalLines.get(2))
+                                        .maxLength(256)
+                                        .build(),
+                                DialogInput.text("line4", Messages.get("gui.sign-edit.inputs.line4"))
+                                        .initial(finalLines.get(3))
+                                        .maxLength(256)
+                                        .build()
+                        ))
+                        .build())
+                .type(DialogType.multiAction(actionButtons).build())
+        );
+    }
+
+    private static List<String> getLines(Sign sign){
+        List<String> lines = new ArrayList<>();
+
+        if (PDC.getUniversal(sign, "line1", PersistentDataType.STRING) != null){
+            for (int i = 1; i<5; i++){
+                lines.add((String) PDC.getUniversal(sign, "line" + i,PersistentDataType.STRING));
+            }
+            return lines;
+        }
+
+        SignSide signSide = sign.getSide(Side.FRONT);
+        List<Component> componentLines = signSide.lines();
+
+        for (Component componentLine : componentLines){
+            lines.add(MiniMessage.miniMessage().serialize(componentLine));
+        }
+
+        return lines;
+    }
+
+    private static void copySignText(DialogResponseView view, Player player, Sign sign){
+        List<String> lines = new ArrayList<>();
+
+        lines.add(view.getText("line1"));
+        lines.add(view.getText("line2"));
+        lines.add(view.getText("line3"));
+        lines.add(view.getText("line4"));
+
+        clipBoard.put(player, lines);
+        Messages.send(player, "gui.sign-edit.success.copied");
+        pasteSignText(sign, player);
+    }
+
+
+    private static void pasteSignText(Sign sign, Player player){
+        Dialog dialog = buildEditDialog(sign, player, clipBoard.get(player));
+        player.showDialog(dialog);
+    }
+
+    private static void editSign(DialogResponseView view, Sign sign, Audience audience){
+        MiniMessage mm = MiniMessage.miniMessage();
+        SignSide signSide = sign.getSide(Side.FRONT);
+
+        List<Component> lines = new ArrayList<>();
+
+
+        for (int i = 1; i < 5; i++) {
+            String key = "line" + i;
+            String line = view.getText(key);
+
+            if (line == null){
+                line = "";
+            }
+
+            PDC.setUniversal(sign, key, line, PersistentDataType.STRING);
+            signSide.line(i-1, mm.deserialize(line));
+
+        }
+        sign.update();
+
+    }
+
+
+}

src/main/java/xyz/soukup/ecoCraftCore/sit/LetMeSit.java

@@ -0,0 +1,142 @@
+package xyz.soukup.ecoCraftCore.sit;
+
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.Bisected;
+import org.bukkit.block.data.type.Stairs;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.event.vehicle.VehicleExitEvent;
+import org.bukkit.persistence.PersistentDataType;
+import xyz.soukup.ecoCraftCore.utilities.PDC;
+
+
+public class LetMeSit implements Listener {
+
+    @EventHandler
+    public void onStairsClick(PlayerInteractEvent event){
+        Player player = event.getPlayer();
+
+        if (player.isSneaking()){
+            return;
+        }
+
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK){
+            return;
+        }
+
+        Block block = event.getClickedBlock();
+
+        if (block == null){
+            return;
+        }
+
+        if (!(block.getBlockData() instanceof Stairs stairs)){
+            return;
+        }
+
+        if (stairs.getHalf() == Bisected.Half.TOP){
+            return;
+        }
+
+        switch (stairs.getShape()) {
+            case INNER_LEFT:
+            case INNER_RIGHT:
+            case OUTER_LEFT:
+            case OUTER_RIGHT:
+                return;
+        }
+
+        float yaw = switch (stairs.getFacing()) {
+            case NORTH -> 0f;
+            case WEST -> -90f;
+            case EAST -> 90f;
+            default -> 180f;
+        };
+
+        Location location = block.getLocation();
+        location.add(0.5, 0.5, 0.5);
+        location.setYaw(yaw);
+
+        World world = location.getWorld();
+
+
+
+        for (Entity entity : world.getNearbyEntities(location, 0.5, 1,0.5)){
+            if (!(entity instanceof ArmorStand armorStand)){
+                continue;
+            }
+
+            if (PDC.getUniversal(armorStand, "chair", PersistentDataType.BOOLEAN) == null){
+                continue;
+            }
+
+            if (!armorStand.getPassengers().isEmpty()){
+                return;
+            }
+
+            player.setRotation(armorStand.getYaw(), 0f);
+            armorStand.addPassenger(player);
+            event.setCancelled(true);
+            return;
+        }
+
+        ArmorStand armorStand = world.spawn(location, ArmorStand.class, stand -> {
+            stand.setInvisible(true);
+            stand.setInvulnerable(true);
+            stand.setGravity(false);
+            stand.setSilent(true);
+            stand.setMarker(true);
+        });
+
+        PDC.setUniversal(armorStand, "chair", true, PersistentDataType.BOOLEAN);
+        player.setRotation(yaw, 0f);
+        armorStand.addPassenger(player);
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void unmount(VehicleExitEvent event){
+        Location location = event.getVehicle().getLocation();
+        cleanArmorStand(location);
+    }
+
+    @EventHandler
+    public void playerLeave(PlayerQuitEvent event){
+        Location location = event.getPlayer().getLocation();
+        cleanArmorStand(location);
+    }
+
+    @EventHandler
+    public void teleport(PlayerTeleportEvent event){
+        Location location = event.getFrom();
+        cleanArmorStand(location);
+    }
+
+    private void cleanArmorStand(Location location){
+        World world = location.getWorld();
+        for (Entity entity : world.getNearbyEntities(location, 0.5, 1,0.5)){
+            if (!(entity instanceof ArmorStand armorStand)){
+                continue;
+            }
+
+            if (PDC.getUniversal(armorStand, "chair", PersistentDataType.BOOLEAN) == null){
+                continue;
+            }
+
+            if (!armorStand.getPassengers().isEmpty()){
+                continue;
+            }
+
+            armorStand.remove();
+        }
+    }
+}

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/java/xyz/soukup/ecoCraftCore/virtualChest/VirtualChestLogic.java

@@ -1,17 +1,24 @@
 package xyz.soukup.ecoCraftCore.virtualChest;
 
-import org.bukkit.block.Chest;
+import com.github.stefvanschie.inventoryframework.gui.GuiItem;
-import org.bukkit.block.DoubleChest;
+import com.github.stefvanschie.inventoryframework.gui.type.HopperGui;
-import org.bukkit.block.TileState;
+import com.github.stefvanschie.inventoryframework.pane.OutlinePane;
+import org.bukkit.Material;
+import org.bukkit.block.*;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
 import org.bukkit.event.inventory.InventoryCloseEvent;
 import org.bukkit.event.inventory.InventoryMoveItemEvent;
 import org.bukkit.event.inventory.InventoryOpenEvent;
 import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.inventory.ItemStack;
-import xyz.soukup.ecoCraftCore.inventory.VirtualChest;
+import xyz.soukup.ecoCraftCore.database.objects.Shop;
+import xyz.soukup.ecoCraftCore.gui.GuiItemBuilder;
+import xyz.soukup.ecoCraftCore.database.objects.VirtualChest;
+import xyz.soukup.ecoCraftCore.messages.Messages;
 import xyz.soukup.ecoCraftCore.utilities.PDC;
 
 import java.util.HashMap;
@@ -20,6 +27,39 @@ public class VirtualChestLogic implements Listener {
 
     public static HashMap<Integer, Integer> openedChests = new HashMap<>();
 
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void blockBreak(BlockBreakEvent event){
+        Block block = event.getBlock();
+        BlockState blockState = block.getState();
+        Player player = event.getPlayer();
+
+        Integer id;
+
+        if (blockState instanceof Chest chest){
+            id = PDC.getInteger(chest, "virtual");
+        } else if (blockState instanceof DoubleChest doubleChest) {
+            id = PDC.getInteger((TileState) doubleChest.getRightSide(), "virtual");
+        }else {
+            return;
+        }
+
+        if (id == null){
+            return;
+        }
+
+        VirtualChest virtualChest = VirtualChest.findById(id);
+
+        if (virtualChest == null){
+            return;
+        }
+
+        event.setCancelled(true);
+
+        HopperGui gui = confirmBreakGui(block, virtualChest);
+        gui.show(player);
+
+    }
+
     @EventHandler
     public void chestOpen(InventoryOpenEvent event){
         InventoryHolder inventoryHolder = event.getInventory().getHolder();
@@ -143,8 +183,43 @@ public class VirtualChestLogic implements Listener {
 
        virtualChest.save();
 
+    }
+    public static HopperGui confirmBreakGui(Block block, VirtualChest virtualChest){
+        HopperGui gui = new HopperGui(Messages.getAsString("menu.destroy-confirmation.title"));
+        OutlinePane pane = new OutlinePane(0,0, 5, 1);
+
+        gui.setOnGlobalClick(inventoryClickEvent -> {
+            inventoryClickEvent.setCancelled(true);
+        });
+
+        GuiItem confirmButton = new GuiItemBuilder(Material.LIME_WOOL)
+                .setName(Messages.get("menu.destroy-confirmation.confirm"))
+                .build();
+
+        GuiItem cancelButton = new GuiItemBuilder(Material.RED_WOOL)
+                .setName(Messages.get("menu.destroy-confirmation.cancel"))
+                .build();
+
+        cancelButton.setAction(event -> {
+            event.getClickedInventory().close();
+        });
 
+        confirmButton.setAction(event -> {
+            destroyShopAndBlock(block, virtualChest);
+            event.getClickedInventory().close();
+        });
 
+        pane.addItem(confirmButton);
+        pane.addItem(cancelButton);
+
+        gui.getSlotsComponent().addPane(pane);
+
+
+        return gui;
+    }
 
+    private static void destroyShopAndBlock(Block block, VirtualChest virtualChest){
+        block.breakNaturally();
+        virtualChest.deleteSelfAndShops();
     }
 }

src/main/resources/config.yml

@@ -9,4 +9,41 @@ database:
   password: "ecc"
   database: "ecc"
 cache:
-  save-interval: 6000
+  save-interval: 6000
+islands:
+  spawn: null
+
+mine:
+  paste-on-startup: false
+  spawn:
+    x: 5.5
+    y: 311.0
+    z: 5.5
+    yaw: 0.0
+    pitch: 0.0
+  generator:
+    rooms-directory: "rooms"
+    starter-room: "ST15"
+    default-biome: "ST"
+    room-size: 16
+    max-depth: 64
+    max-rooms: 320
+    ignore-air: false
+    origin:
+      x: 0
+      y: 310
+      z: 0
+    depth-biomes:
+      - biome: "ST"
+        min-depth: 0
+      - biome: "DS"
+        min-depth: 20
+      - biome: "MS"
+        min-depth: 40
+    natural-biomes:
+      - biome: "DS"
+        chance: 0.08
+        length: 6
+      - biome: "MS"
+        chance: 0.05
+        length: 5

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,14 @@ generic:
     no-item:
       self: "<red>Nemáš dostatek itemů"
       shop: "<red>Obchod nemá dostatek itemů"
+region:
+  error:
+    not-marked: "<red>Musíš nejprve označit pozice"
+    not-exist: "<red>Region neexistuje"
+    not-allowed-to-interact: "<red>Nemáš povolení dělat změny na tomto území"
+sign-edit:
+  error:
+    not-sign: "<red>Musíš se dívat na cedulku."
 shop:
   error:
     already-shop: "<red>Tato cedule již je obchod"
@@ -44,6 +54,16 @@ marker:
     primary: "<green>První pozice označena (<x>,<y>,<z>)"
     secondary: "<green>Druhá pozice označena (<x>,<y>,<z>)"
 menu:
+  destroy-confirmation:
+    title: "<gold>Zníčit obchod?"
+    confirm: "<green><bold>Ano."
+    cancel: "<red><bold>Ne."
+  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>$"
@@ -51,6 +71,22 @@ gui:
   error:
     invalid-input: "<red>Vámi zadané hodnoty nejsou platné."
   all: "<green>Seznam guis: <yellow><1>, <2>"
+  sign-edit:
+    title: "<green><bold>Editace Cedulky"
+    inputs:
+      line1: "<yellow>1. Linka"
+      line2: "<yellow>2. Linka"
+      line3: "<yellow>3. Linka"
+      line4: "<yellow>4. Linka"
+      glow: "<yellow>Zvíraznit text"
+    buttons:
+      confirm: "<green>Potvrdit"
+      cancel: "<red>Zrušit"
+      copy: "<yellow>Kopírovat"
+      paste: "<yellow>Vložit"
+    success:
+      copied: "<green>Obsah cedulky zkopírován!"
+      pasted: "<green>Obsah cedulky vložen!"
   shop-edit:
     title: "<green><bold>Editace Obchodu"
     inputs:
@@ -65,4 +101,12 @@ gui:
     title: "<dark_green>Obchod"
     buy: "<green>Koupit <amount>ks za <price>$"
     sell: "<yellow>Prodat <amount>ks za <price>$"
+mine:
+  regenerating: "<green>Regenerace dolů začala..."
+  regenerate-complete: "<green>Regenerace dolů dokončena."
+  teleporting: "<green>Teleportuješ se do dolů."
+  teleported-out: "<yellow>Byl jsi teleportován z dolů kvůli regeneraci."
+  error:
+    no-world: "<red>Důlní svět není načtený."
+    regenerate-failed: "<red>Regenerace dolů selhala. Zkontroluj room prefab soubory a server log."
 

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
+