Update README.md

Fix on respawn

.gitignore

@@ -21,4 +21,6 @@ gradle-app.setting
 .classpath
 
 run
-.idea
+.idea
+.gradle
+build

README.md

@@ -1,15 +1,28 @@
 # NoDropX
 Give no drop items!
+=======
+<img src="https://i.imgur.com/4KNCfzl.png"></img>
+
+# NoDropX
+**Give no drop items!**
 
 The plugin will allow you to create items that will not drop out of your inventory at death!
 
-Give an no drop item: /nodrop give [player] [item] (count)
+Give an no drop item: `/nodrop give [player] [item] (count)` <br>
+Check all plugin commands: https://github.com/iRedTea/NoDropX/wiki/Commands <br>
+Plugin wiki: https://github.com/iRedTea/NoDropX/wiki <br>
+SpigotMC resource: https://www.spigotmc.org/resources/nodropx.111485/
 
-features:
-- Support HEX Colors (MiniMessages and MD5 ChatColor)
-- Support all versions from 1.12.2 to 1.20.1
-- No drop items storage: /nodrop gui
+**Features**
+- Supports HEX Colors (MiniMessages and MD5 ChatColor)
+- Supports all versions from 1.12.2 to 1.20.1 (Spigot/Paper/Folia)
+- No drop items storage: `/nodrop gui`
 - Fully customization
 - Items that protect other slots from death
+- Developer API
+- Mods support (tested on Arclight 1.16.5)
+- ItemsAdder support
+- Folia support
 
-<img src="https://i.imgur.com/s2BwNH5.png"></img>
+
+This plugin uses <a href="https://github.com/iRedTea/CarcadeX">CarcadeX</a> library

build.gradle

@@ -5,7 +5,7 @@ plugins {
 }
 
 group = 'me.redtea'
-version = '1.0.0-SNAPSHOT'
+version = '1.0.3-SNAPSHOT'
 
 repositories {
     mavenCentral()
@@ -25,20 +25,24 @@ repositories {
         name = "papermc-repo"
         url = "https://repo.papermc.io/repository/maven-public/"
     }
+    maven {
+        url 'https://jitpack.io'
+    }
 }
 
 dependencies {
-    implementation 'org.jetbrains:annotations:24.0.0'
-    compileOnly 'org.projectlombok:lombok:1.18.26'
+    implementation "org.jetbrains:annotations:24.0.0"
+    compileOnly "org.projectlombok:lombok:1.18.26"
     annotationProcessor 'org.projectlombok:lombok:1.18.26'
     compileOnly "com.destroystokyo.paper:paper-api:1.16.5-R0.1-SNAPSHOT"
     implementation "me.mattstudios.utils:matt-framework:1.4"
-    implementation 'de.tr7zw:item-nbt-api:2.11.3'
+    implementation "de.tr7zw:item-nbt-api:2.11.3"
     implementation "net.kyori:adventure-api:4.14.0"
     implementation "net.kyori:adventure-platform-bukkit:4.3.0"
     implementation files("libs/MiniMessages.jar")
-    compileOnly files("libs/nodropxforgebridge-1.1.jar")
     implementation "dev.triumphteam:triumph-gui:3.1.2"
+    compileOnly "com.github.LoneDev6:API-ItemsAdder:3.5.0b"
+    compileOnly files("libs/nodropxforgebridge-1.4.jar")
 }
 
 def targetJavaVersion = 8

src/main/java/me/redtea/nodropx/NoDropX.java

@@ -10,22 +10,39 @@ import me.redtea.nodropx.factory.item.impl.NoDropItemFactoryImpl;
 import me.redtea.nodropx.factory.text.TextContext;
 import me.redtea.nodropx.factory.text.TextServicesFactory;
 import me.redtea.nodropx.factory.text.impl.TextServicesFactoryImpl;
-import me.redtea.nodropx.gui.facade.GuiFacade;
-import me.redtea.nodropx.gui.facade.impl.GuiFacadeImpl;
-import me.redtea.nodropx.gui.pages.StorageGui;
+import me.redtea.nodropx.folia.FoliaSupporter;
 import me.redtea.nodropx.libs.bstats.Metrics;
 import me.redtea.nodropx.libs.carcadex.repo.MutableRepo;
 import me.redtea.nodropx.libs.carcadex.repo.Repo;
-import me.redtea.nodropx.libs.carcadex.repo.impl.yaml.YamlRepo;
 import me.redtea.nodropx.libs.message.container.Messages;
+import me.redtea.nodropx.libs.message.verifier.impl.FileMessageVerifier;
+import me.redtea.nodropx.listener.ConfirmDropHandler;
 import me.redtea.nodropx.listener.InventoryHandler;
 import me.redtea.nodropx.listener.PlayerHandler;
+import me.redtea.nodropx.listener.menu.SinglePageGuiHandler;
+import me.redtea.nodropx.menu.CachedMenu;
+import me.redtea.nodropx.menu.Menu;
+import me.redtea.nodropx.menu.dropconfirm.DropConfirmMFGui;
+import me.redtea.nodropx.menu.facade.MenuFacade;
+import me.redtea.nodropx.menu.facade.impl.MenuFacadeImpl;
+import me.redtea.nodropx.menu.storage.pages.MFPageGui;
+import me.redtea.nodropx.menu.storage.singlepage.SinglePageController;
+import me.redtea.nodropx.menu.storage.singlepage.SinglePageGui;
 import me.redtea.nodropx.model.cosmetic.impl.DisplayNameCosmetic;
+import me.redtea.nodropx.model.materialprovider.impl.ItemStackProviderDefault;
+import me.redtea.nodropx.model.materialprovider.impl.ItemsAdderProvider;
 import me.redtea.nodropx.schema.ItemStackListSchema;
+import me.redtea.nodropx.service.capasity.CapacityService;
+import me.redtea.nodropx.service.capasity.impl.CapacityServiceImpl;
 import me.redtea.nodropx.service.cosmetic.CosmeticService;
 import me.redtea.nodropx.service.cosmetic.impl.CosmeticServiceImpl;
+import me.redtea.nodropx.service.dropconfirm.DropConfirmService;
+import me.redtea.nodropx.service.dropconfirm.impl.DropConfirmNull;
+import me.redtea.nodropx.service.dropconfirm.impl.DropConfirmServiceImpl;
 import me.redtea.nodropx.service.event.EventService;
 import me.redtea.nodropx.service.event.impl.EventServiceImpl;
+import me.redtea.nodropx.service.material.ItemStackService;
+import me.redtea.nodropx.service.material.impl.ItemStackServiceImpl;
 import me.redtea.nodropx.service.nbt.NBTService;
 import me.redtea.nodropx.service.nbt.impl.Tr7zwNBTServiceImpl;
 import me.redtea.nodropx.service.nodrop.NoDropService;
@@ -34,91 +51,92 @@ import me.redtea.nodropx.service.respawn.RespawnService;
 import me.redtea.nodropx.service.respawn.impl.RespawnServiceImpl;
 import me.redtea.nodropx.service.storage.StorageService;
 import me.redtea.nodropx.service.storage.impl.StorageServiceImpl;
-import me.redtea.nodropxforgebridge.ApiProvider;
-import me.redtea.nodropxforgebridge.Nodropxforgebridge;
+import me.redtea.nodropx.util.ConfigVerifier;
+import me.redtea.nodropx.util.FoliaSupportedUtils;
+import me.redtea.nodropx.util.UpdateChecker;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
-import org.bukkit.Material;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.ServicePriority;
 import org.bukkit.plugin.java.JavaPlugin;
 
 import java.io.File;
-import java.util.Arrays;
-import java.util.Collection;
 import java.util.List;
 import java.util.UUID;
-import java.util.stream.Collectors;
 
 public final class NoDropX extends JavaPlugin {
     private static NoDropAPI noDropAPIInstance;
     @Getter
     private static NoDropX instance;
-
+    @Getter
     private Messages messages;
-    private CosmeticService cosmeticService;
+    private CosmeticService noDropCosmeticService;
     @Getter
     private boolean supportHEX;
     @Getter
     private boolean supportKyoriLore;
-    private MutableRepo<UUID, List<ItemStack>> pagesRepo;
-    private Repo<String, List<Integer>> capacity;
-
+    @Getter
+    private boolean supportItemsAdder;
+    private MutableRepo<UUID, List<ItemStack>> personalStorageRepo;
+    private CapacityService capacityService;
+    private MenuFacade menuFacade;
+    private NoDropService noDropService;
+    private ItemStackService itemStackService;
+    private DropConfirmService dropConfirmService;
+    private FoliaSupportedUtils foliaSupportedUtils;
 
     @Override
     public void onEnable() {
         instance = this;
-        saveDefaultConfig();
+        new ConfigVerifier().verifyDefaults(this);
+
+        foliaSupportedUtils = new FoliaSupportedUtils(this);
 
         TextServicesFactory textServicesFactory = new TextServicesFactoryImpl();
         TextContext textContext = textServicesFactory.create(this);
         supportHEX = textContext.isSupportHex();
         supportKyoriLore = textContext.isSupportKyori();
         messages = supportKyoriLore ? Messages.of(textContext.getMessages()) : Messages.legacy(textContext.getMessages());
+        messages.setVerifier(new FileMessageVerifier(getResource(textContext.getPath()), YamlConfiguration.loadConfiguration(textContext.getMessages()), textContext.getMessages()));
 
-        cosmeticService = new CosmeticServiceImpl();
-        cosmeticService.add(new DisplayNameCosmetic());
-        cosmeticService.add(textContext.getLoreStrategy());
-        cosmeticService.load(YamlConfiguration.loadConfiguration(textContext.getCosmetics()));
-
-        capacity = new YamlRepo<>(
-                new File(getDataFolder(), "capacity.yml").toPath(),
-                this,
-                conf -> conf.getKeys(false).stream().collect(Collectors.toMap(
-                        value -> value,
-                        conf::getIntegerList))
-        );
+        noDropCosmeticService = new CosmeticServiceImpl();
+        noDropCosmeticService.add(new DisplayNameCosmetic());
+        noDropCosmeticService.add(textContext.getLoreStrategy());
+        noDropCosmeticService.load(YamlConfiguration.loadConfiguration(textContext.getCosmetics()));
 
         NBTService nbtService = new Tr7zwNBTServiceImpl();
-        NoDropService noDropService = new NoDropServiceImpl(nbtService, cosmeticService);
+        noDropService = new NoDropServiceImpl(nbtService, noDropCosmeticService);
         NoDropItemFactory noDropItemFactory = new NoDropItemFactoryImpl(noDropService);
         EventService eventService = new EventServiceImpl(noDropService);
-        RespawnService respawnService = new RespawnServiceImpl(noDropService, capacity);
-        pagesRepo = Repo.<UUID, List<ItemStack>>builder()
+        capacityService = new CapacityServiceImpl(this);
+        RespawnService respawnService = new RespawnServiceImpl(noDropService, capacityService);
+
+        //EXPERIMENTAL! Folia support!
+        FoliaSupporter foliaSupporter = new FoliaSupporter();
+        foliaSupporter.run(respawnService, this);
+
+        personalStorageRepo = Repo.<UUID, List<ItemStack>>builder()
                 .autoSave(1000 * 60 * 15L)
                 .schema(new ItemStackListSchema(new File(getDataFolder(), "storage")))
                 .plugin(this)
                 .build();
+        itemStackService = initItemStackService();
+
+        dropConfirmService = getConfig().getBoolean("confirmThrowNoDropItem") ? new DropConfirmServiceImpl() : new DropConfirmNull();
+
+        menuFacade = initMenus();
+        StorageService storageService = new StorageServiceImpl(menuFacade, personalStorageRepo, noDropService);
 
 
-        GuiFacade guiFacade = new GuiFacadeImpl(
-                new StorageGui(messages, pagesRepo, noDropService, this)
-        );
-        StorageService storageService = new StorageServiceImpl(guiFacade, pagesRepo, noDropService);
 
-        NoDropAPI noDropAPI = new NoDropXFacade(noDropService, noDropItemFactory, storageService, capacity);
+        NoDropAPI noDropAPI = new NoDropXFacade(noDropService, noDropItemFactory, storageService, capacityService, itemStackService);
         noDropAPIInstance = noDropAPI;
 
 
-        Bukkit.getPluginManager().registerEvents(
-                new InventoryHandler(eventService),
-                this
-        );
-        Bukkit.getPluginManager().registerEvents(
-                new PlayerHandler(respawnService, eventService, guiFacade),
-                this
-        );
+        Bukkit.getPluginManager().registerEvents(new InventoryHandler(eventService, noDropService, dropConfirmService), this);
+        Bukkit.getPluginManager().registerEvents(new PlayerHandler(respawnService, eventService, menuFacade), this);
+        Bukkit.getPluginManager().registerEvents(new ConfirmDropHandler(dropConfirmService, menuFacade), this);
 
         Bukkit.getServicesManager().register(NoDropAPI.class,
                 noDropAPI, this, ServicePriority.Normal);
@@ -128,17 +146,49 @@ public final class NoDropX extends JavaPlugin {
         commandManager.getMessageHandler().register("cmd.no.console", sender -> messages.get("noConsole").send(sender));
         commandManager.getMessageHandler().register("cmd.no.exists", sender -> messages.get("noExists").send(sender));
         commandManager.getMessageHandler().register("cmd.wrong.usage", sender -> messages.get("usage").send(sender));
-        commandManager.getCompletionHandler().register("#materials", input -> Arrays.stream(Material.values()).map(Enum::name).collect(Collectors.toList()));
-        commandManager.register(new NoDropCommand(messages, noDropAPI, guiFacade, this));
+        commandManager.getCompletionHandler().register("#materials", input -> itemStackService.allMaterials());
+        commandManager.register(new NoDropCommand(messages, noDropAPI, menuFacade, this, itemStackService));
         bStatsInit();
         printCredits();
-
-        mod();
+        checkUpdates();
     }
 
-    //todo remove
-    private void mod() {
-        Nodropxforgebridge.noDropAPI = s -> getAPI().getCapacitySlots(s);
+    private MenuFacade initMenus() {
+        CachedMenu personalStorageCachedMenu;
+        if(getConfig().getString("personalStorageType").equalsIgnoreCase("SINGLE_PAGE")) {
+            SinglePageGui singlePageGui = new SinglePageGui(messages, personalStorageRepo);
+            personalStorageCachedMenu = singlePageGui;
+            Bukkit.getPluginManager().registerEvents(new SinglePageGuiHandler(new SinglePageController(noDropService,
+                    singlePageGui, personalStorageRepo, foliaSupportedUtils), singlePageGui), this);
+        } else personalStorageCachedMenu =  new MFPageGui(messages, personalStorageRepo, noDropService, itemStackService, this);
+
+        Menu confirmMenu = new DropConfirmMFGui(messages, dropConfirmService);
+        return new MenuFacadeImpl(personalStorageCachedMenu, confirmMenu);
+    }
+
+    private ItemStackService initItemStackService() {
+        ItemStackService result = new ItemStackServiceImpl();
+        if (Bukkit.getPluginManager().getPlugin("ItemsAdder") != null) {
+            supportItemsAdder = true;
+            getLogger().info(ChatColor.GREEN + "ItemsAdder found! Registering a CustomStack provider for it.");
+            result.registerProvider(new ItemsAdderProvider());
+        }
+        result.registerProvider(new ItemStackProviderDefault());
+        return result;
+    }
+
+    private void checkUpdates() {
+        if(!getConfig().getBoolean("checkForUpdates")) {
+            return;
+        }
+        new UpdateChecker(this, 111485, foliaSupportedUtils).getVersion(version -> {
+            if (this.getDescription().getVersion().equals(version)) {
+                getLogger().info("There is not a new update available.");
+            } else {
+                getLogger().info("There is a new update available: " + version);
+                getLogger().info("Download it from https://www.spigotmc.org/resources/nodropx.111485/");
+            }
+        });
     }
 
 
@@ -159,15 +209,16 @@ public final class NoDropX extends JavaPlugin {
     }
 
     public void onReload() {
-        pagesRepo.saveAll();
-        capacity.reload();
+        personalStorageRepo.saveAll();
+        menuFacade.clearAllCache();
+        capacityService.reload();
         messages.reload(YamlConfiguration.loadConfiguration(new File(getDataFolder(), "messages.yml")));
-        cosmeticService.load(YamlConfiguration.loadConfiguration(new File(getDataFolder(), "cosmetics.yml")));
+        noDropCosmeticService.load(YamlConfiguration.loadConfiguration(new File(getDataFolder(), "cosmetics.yml")));
     }
 
     @Override
     public void onDisable() {
-        pagesRepo.saveAll();
+        personalStorageRepo.saveAll();
     }
 
     public static NoDropAPI getAPI() {

src/main/java/me/redtea/nodropx/api/facade/NoDropAPI.java

@@ -1,7 +1,7 @@
 package me.redtea.nodropx.api.facade;
 
+import lombok.val;
 import me.redtea.nodropx.api.facade.manipulator.StorageManipulator;
-import me.redtea.nodropx.util.MaterialUtils;
 import org.bukkit.Material;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.entity.HumanEntity;
@@ -22,7 +22,7 @@ public interface NoDropAPI {
      * @author redtea
      * @since 1.0.0
      */
-    void setNoDrop(@NotNull ItemStack item, boolean isNoDrop);
+    ItemStack setNoDrop(@NotNull ItemStack item, boolean isNoDrop);
 
     /**
      * Check if item is no drop item
@@ -41,8 +41,20 @@ public interface NoDropAPI {
      * @author redtea
      * @since 1.0.0
      */
-    ItemStack getNoDrop(@NotNull Material material, int amount);
+    default ItemStack getNoDrop(@NotNull Material material, int amount) {
+        val item = new ItemStack(material, amount);
+        setNoDrop(item, true);
+        return item;
+    }
 
+    /**
+     * Gives the entity no drop item
+     * @param entity who will get no drop item
+     * @param item no drop item
+     * @author redtea
+     * @since 1.0.0
+     */
+    void giveNoDrop(@NotNull HumanEntity entity, @NotNull ItemStack item);
 
     /**
      * Gives the entity no drop item
@@ -52,7 +64,9 @@ public interface NoDropAPI {
      * @author redtea
      * @since 1.0.0
      */
-    void giveNoDrop(@NotNull HumanEntity entity, @NotNull Material material, int amount);
+    default void giveNoDrop(@NotNull HumanEntity entity, @NotNull Material material, int amount) {
+        giveNoDrop(entity, getNoDrop(material, amount));
+    }
 
     /**
      * returns an object for accessing the storage of a player with UUID playerUniqueId
@@ -64,7 +78,16 @@ public interface NoDropAPI {
     @NotNull StorageManipulator getStorageManipulator(@NotNull UUID playerUniqueId);
 
     /**
-     * returns the slot numbers that an no drop item with this material saves at death
+     * returns the slot numbers that no drop item with this itemStack saves at death
+     * @param itemStack itemStack to check
+     * @return numbers of saved slots
+     * @author redtea
+     * @since 1.0.3
+     */
+    @NotNull Collection<Integer> getCapacitySlots(ItemStack itemStack);
+
+    /**
+     * returns the slot numbers that no drop item with this material saves at death
      * @param material material to check
      * @return numbers of saved slots
      * @author redtea
@@ -75,9 +98,7 @@ public interface NoDropAPI {
     /**
      * @see NoDropAPI#getCapacitySlots(Material)
      */
-    default @NotNull Collection<Integer> getCapacitySlots(String material) {
-        return getCapacitySlots(MaterialUtils.getMaterialFromString(material));
-    }
+    @NotNull Collection<Integer> getCapacitySlots(String material);
 
     /**
      * @see NoDropAPI#getStorageManipulator(UUID) 
@@ -89,9 +110,7 @@ public interface NoDropAPI {
     /**
      * @see NoDropAPI#giveNoDrop(HumanEntity, Material, int)
      */
-    default void giveNoDrop(@NotNull HumanEntity entity, @NotNull String material, int amount) {
-        giveNoDrop(entity, MaterialUtils.getMaterialFromString(material), amount);
-    }
+    void giveNoDrop(@NotNull HumanEntity entity, @NotNull String material, int amount);
 
     /**
      * @see NoDropAPI#giveNoDrop(HumanEntity, Material, int)
@@ -110,9 +129,7 @@ public interface NoDropAPI {
     /**
      * @see NoDropAPI#getNoDrop(Material, int)
      */
-    default @NotNull ItemStack getNoDrop(@NotNull String material, int amount) {
-        return getNoDrop(MaterialUtils.getMaterialFromString(material), amount);
-    }
+    @NotNull ItemStack getNoDrop(@NotNull String material, int amount);
 
     /**
      * @see NoDropAPI#getNoDrop(Material, int)

src/main/java/me/redtea/nodropx/api/facade/impl/NoDropXFacade.java

@@ -5,6 +5,8 @@ import me.redtea.nodropx.api.facade.manipulator.StorageManipulator;
 import lombok.RequiredArgsConstructor;
 import me.redtea.nodropx.factory.item.NoDropItemFactory;
 import me.redtea.nodropx.libs.carcadex.repo.Repo;
+import me.redtea.nodropx.service.capasity.CapacityService;
+import me.redtea.nodropx.service.material.ItemStackService;
 import me.redtea.nodropx.service.nodrop.NoDropService;
 import me.redtea.nodropx.service.storage.StorageService;
 import org.bukkit.Material;
@@ -23,11 +25,13 @@ public class NoDropXFacade implements NoDropAPI {
     private final NoDropService noDropService;
     private final NoDropItemFactory itemFactory;
     private final StorageService storageService;
-    private final Repo<String, List<Integer>> capacity;
+    private final CapacityService capacityService;
+    private final ItemStackService itemStackService;
 
     @Override
-    public void setNoDrop(@NotNull ItemStack item, boolean isNoDrop) {
+    public ItemStack setNoDrop(@NotNull ItemStack item, boolean isNoDrop) {
         noDropService.setNoDrop(item, isNoDrop);
+        return item;
     }
 
     @Override
@@ -41,6 +45,11 @@ public class NoDropXFacade implements NoDropAPI {
         return itemFactory.createNoDrop(material, amount);
     }
 
+    @Override
+    public void giveNoDrop(@NotNull HumanEntity entity, @NotNull ItemStack item) {
+        entity.getInventory().addItem(setNoDrop(item, true));
+    }
+
     @Override
     public void giveNoDrop(@NotNull HumanEntity entity, @NotNull Material material, int amount) {
         entity.getInventory().addItem(getNoDrop(material, amount));
@@ -66,8 +75,28 @@ public class NoDropXFacade implements NoDropAPI {
         };
     }
 
+    @Override
+    public @NotNull Collection<Integer> getCapacitySlots(ItemStack itemStack) {
+        return capacityService.get(itemStack);
+    }
+
     @Override
     public @NotNull Collection<Integer> getCapacitySlots(Material material) {
-        return capacity.get(material.name()).orElse(new ArrayList<>());
+        return capacityService.get(material);
+    }
+
+    @Override
+    public @NotNull Collection<Integer> getCapacitySlots(String material) {
+        return getCapacitySlots(itemStackService.get(material, 1).getType());
+    }
+
+    @Override
+    public void giveNoDrop(@NotNull HumanEntity entity, @NotNull String material, int amount) {
+        giveNoDrop(entity, itemStackService.get(material, amount));
+    }
+
+    @Override
+    public @NotNull ItemStack getNoDrop(@NotNull String material, int amount) {
+        return setNoDrop(itemStackService.get(material, amount), true);
     }
 }

src/main/java/me/redtea/nodropx/command/NoDropCommand.java

@@ -1,14 +1,19 @@
 package me.redtea.nodropx.command;
 
 import lombok.RequiredArgsConstructor;
+import lombok.val;
 import me.mattstudios.mf.annotations.*;
 import me.mattstudios.mf.base.CommandBase;
 import me.redtea.nodropx.NoDropX;
 import me.redtea.nodropx.api.facade.NoDropAPI;
-import me.redtea.nodropx.gui.facade.GuiFacade;
+import me.redtea.nodropx.menu.facade.MenuFacade;
 import me.redtea.nodropx.libs.message.container.Messages;
+import me.redtea.nodropx.service.material.ItemStackService;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Date;
 
@@ -22,8 +27,9 @@ import java.util.Date;
 public class NoDropCommand extends CommandBase {
     private final Messages messages;
     private final NoDropAPI noDropAPI;
-    private final GuiFacade guiFacade;
+    private final MenuFacade menuFacade;
     private final NoDropX plugin;
+    private final ItemStackService itemStackService;
 
     @Default
     public void onDefault(final CommandSender sender) {
@@ -38,11 +44,11 @@ public class NoDropCommand extends CommandBase {
                        final String material,
                        @Optional final Integer amount) {
         try {
-            noDropAPI.giveNoDrop(player, material, amount == null ? 1 : amount);
+            noDropAPI.giveNoDrop(player, material, amount == null || amount == 0 ? 1 : amount);
             messages.get("give.success")
                     .replaceAll("%item%", material)
                     .replaceAll("%player%", player.getName())
-                    .replaceAll("%amount%", amount == null ? "0" : amount.toString())
+                    .replaceAll("%amount%", amount == null ? "1" : amount.toString())
                     .send(sender);
         } catch (Throwable e) {
             messages.get("give.fail").send(sender);
@@ -58,9 +64,55 @@ public class NoDropCommand extends CommandBase {
         messages.get("reload").replaceAll("%time%", String.valueOf(new Date().getTime() - time)).send(sender);
     }
 
+    @SubCommand("giveStorage")
+    @Permission("nodropx.giveStorage")
+    @Completion({"#players", "#materials", "#range:1-64"})
+    public void onGiveStorage(final CommandSender sender,
+                              final String playerName,
+                              final String material,
+                              @Optional final Integer amount) {
+        try {
+            val item = noDropAPI.setNoDrop(itemStackService.get(material, amount == null || amount == 0 ? 1 : amount), true);
+            val player = getOfflinePlayer(playerName);
+            if(player == null) {
+                messages.get("noExists").send(sender);
+                return;
+            }
+            noDropAPI.getStorageManipulator(player).add(item);
+            messages.get("giveToStorage.success")
+                    .replaceAll("%item%", material)
+                    .replaceAll("%player%", playerName)
+                    .replaceAll("%amount%", amount == null ? "1" : amount.toString())
+                    .send(sender);
+        } catch (Throwable e) {
+            messages.get("giveToStorage.fail").send(sender);
+        }
+
+    }
+
+    @SubCommand("applyHand")
+    @Permission("nodropx.applyhand")
+    public void onApplyHand(final Player sender) {
+        try {
+            noDropAPI.setNoDrop(sender.getInventory().getItemInMainHand(), true);
+            messages.get("applyHand.success").send(sender);
+        } catch (Throwable e) {
+            messages.get("applyHand.fail").send(sender);
+        }
+    }
+
     @SubCommand("gui")
+    @Alias("storage")
     @Permission("nodropx.gui")
     public void onGui(final Player sender) {
-        guiFacade.openNoDropStorage(sender);
+        menuFacade.openPersonalStorage(sender);
+    }
+
+    @Nullable
+    private OfflinePlayer getOfflinePlayer(final String name) {
+        for(OfflinePlayer player : Bukkit.getOfflinePlayers()) {
+            if(player.getName() != null && player.getName().equalsIgnoreCase(name)) return player;
+        }
+        return null;
     }
 }

src/main/java/me/redtea/nodropx/factory/text/TextContext.java

@@ -12,4 +12,5 @@ public class TextContext {
     private final File cosmetics;
     private final boolean supportHex;
     private final boolean supportKyori;
+    private final String path;
 }

src/main/java/me/redtea/nodropx/factory/text/impl/TextServicesFactoryImpl.java

@@ -55,7 +55,7 @@ public class TextServicesFactoryImpl implements TextServicesFactory {
             cosmeticStrategy = new LoreMD5Cosmetics();
         } else cosmeticStrategy = new LoreKyoriCosmetic();
 
-        return new TextContext(cosmeticStrategy, messages, cosmetics, isSupportHEX, isSupportKyoriLore);
+        return new TextContext(cosmeticStrategy, messages, cosmetics, isSupportHEX, isSupportKyoriLore, "text/" + folder + "/messages.yml");
     }
 
 

src/main/java/me/redtea/nodropx/folia/FoliaSupporter.java

@@ -0,0 +1,73 @@
+package me.redtea.nodropx.folia;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import lombok.Getter;
+import lombok.SneakyThrows;
+import me.redtea.nodropx.service.respawn.RespawnService;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.plugin.Plugin;
+
+import java.io.FileReader;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+//Experimental. Must be refactored in the future.
+public class FoliaSupporter {
+    private RespawnService respawnService;
+
+    @Getter
+    private static boolean runningOnFolia = false;
+
+    @SneakyThrows
+    public void run(RespawnService respawnService, Plugin plugin) {
+        String version = ((JsonObject) new JsonParser().parse(new FileReader("version_history.json"))).get("currentVersion").getAsString();
+        if(!version.toLowerCase().contains("folia") && !plugin.getConfig().getBoolean("forceUseFoliaPatches")) {
+            return;
+        }
+        runningOnFolia = true;
+        plugin.getLogger().info("Found Folia! Applying patches for this...");
+        this.respawnService = respawnService;
+        Bukkit.getPluginManager().registerEvents(new FoliaDeathListener(), plugin);
+        plugin.getLogger().info("Patches for Folia successfully applied!");
+    }
+
+
+    /*
+    temp fix when folia not called respawn event
+     */
+    class FoliaDeathListener implements Listener {
+        private final Set<Player> toRespawn = new CopyOnWriteArraySet<>();
+
+        public FoliaDeathListener() {
+            new Thread(() -> {
+                while (true) {
+                    for(Player player : toRespawn) {
+                        if(!player.isDead()) {
+                            onRespawn(player);
+                            toRespawn.remove(player);
+                        }
+                    }
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            }).start();
+        }
+
+        public void onRespawn(Player player) {
+            respawnService.giveSavedItems(player);
+        }
+
+        @EventHandler
+        public void onDeath(PlayerDeathEvent event) {
+            toRespawn.add(event.getEntity());
+        }
+    }
+}

src/main/java/me/redtea/nodropx/gui/facade/GuiFacade.java

@@ -1,9 +0,0 @@
-package me.redtea.nodropx.gui.facade;
-
-import org.bukkit.entity.Player;
-
-public interface GuiFacade {
-    void openNoDropStorage(Player player);
-    void clearCache(Player player);
-    void clearAllCache();
-}

src/main/java/me/redtea/nodropx/gui/facade/impl/GuiFacadeImpl.java

@@ -1,26 +0,0 @@
-package me.redtea.nodropx.gui.facade.impl;
-
-import lombok.RequiredArgsConstructor;
-import me.redtea.nodropx.gui.facade.GuiFacade;
-import me.redtea.nodropx.gui.pages.StorageGui;
-import org.bukkit.entity.Player;
-
-@RequiredArgsConstructor
-public class GuiFacadeImpl implements GuiFacade {
-    private final StorageGui storageGui;
-
-    @Override
-    public void openNoDropStorage(Player player) {
-        storageGui.open(player);
-    }
-
-    @Override
-    public void clearCache(Player player) {
-        storageGui.clearCache(player);
-    }
-
-    @Override
-    public void clearAllCache() {
-        storageGui.clearAllCache();
-    }
-}

src/main/java/me/redtea/nodropx/libs/message/container/Messages.java

@@ -5,6 +5,7 @@ import me.redtea.nodropx.libs.message.factory.MessageFactory;
 import me.redtea.nodropx.libs.message.factory.impl.LegacyFactoryImpl;
 import me.redtea.nodropx.libs.message.model.Message;
 import me.redtea.nodropx.libs.message.model.impl.NullMessage;
+import me.redtea.nodropx.libs.message.verifier.MessageVerifier;
 import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.plugin.Plugin;
@@ -119,7 +120,11 @@ public interface Messages {
     /**
      * <h1>Sets custom message parse factory.</h1>
      */
-    void factory(MessageFactory messageFactory);
+    Messages factory(MessageFactory messageFactory);
+
+    Messages init();
+
+    void setVerifier(MessageVerifier verifier);
 
     /**
      * <h1>Create container using configuration section</h1>
@@ -134,7 +139,7 @@ public interface Messages {
      * @return container with messages
      */
     static Messages of(ConfigurationSection section) {
-        return new MessagesImpl(section);
+        return new MessagesImpl(section).init();
     }
 
     /**
@@ -168,7 +173,7 @@ public interface Messages {
      * @return container with messages
      */
     static Messages of(Plugin plugin) {
-        return of(plugin, "text/legacy/messages.yml");
+        return of(plugin, "messages.yml");
     }
 
     /**
@@ -202,28 +207,24 @@ public interface Messages {
      * @return container with messages
      */
     static Messages legacy(ConfigurationSection section) {
-        return asLegacy(of(section));
+        return new MessagesImpl(section).factory(new LegacyFactoryImpl()).init();
     }
 
     /** @see Messages#legacy(ConfigurationSection) */
     static Messages legacy(Plugin plugin, String fileName) {
-        return asLegacy(of(plugin, fileName));
+        File file = new File(plugin.getDataFolder(), fileName);
+        if(!file.exists()) plugin.saveResource(fileName, false);
+        return new MessagesImpl(file).factory(new LegacyFactoryImpl()).init();
     }
 
     /** @see Messages#legacy(ConfigurationSection) */
     static Messages legacy(Plugin plugin) {
-        return asLegacy(of(plugin));
+        return legacy(plugin, "messages.yml");
     }
 
     /** @see Messages#legacy(ConfigurationSection) */
     static Messages legacy(File file) {
-        return asLegacy(of(file));
-    }
-
-    /** @see Messages#legacy(ConfigurationSection) */
-    static Messages asLegacy(Messages messages) {
-        messages.factory(new LegacyFactoryImpl());
-        return messages;
+        return new MessagesImpl(file).factory(new LegacyFactoryImpl()).init();
     }
 
     /**

src/main/java/me/redtea/nodropx/libs/message/container/impl/MessagesImpl.java

@@ -1,5 +1,7 @@
 package me.redtea.nodropx.libs.message.container.impl;
 
+import lombok.Setter;
+import me.redtea.nodropx.libs.message.verifier.MessageVerifier;
 import me.redtea.nodropx.libs.message.container.Messages;
 import me.redtea.nodropx.libs.message.factory.MessageFactory;
 import me.redtea.nodropx.libs.message.model.Message;
@@ -8,9 +10,7 @@ import org.bukkit.configuration.file.YamlConfiguration;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
+import java.util.*;
 
 public class MessagesImpl implements Messages {
     private Map<String, Message> messages;
@@ -19,25 +19,52 @@ public class MessagesImpl implements Messages {
 
     private final Message NULL_MESSAGE = factory.nullMessage();
 
+    private ConfigurationSection section;
+
+    @Setter
+    private MessageVerifier verifier;
+
     public MessagesImpl() {
     }
 
     public MessagesImpl(@NotNull ConfigurationSection section) {
-        messages = fromConfigurationToMap(section);
+        this.section = section;
+    }
+    public MessagesImpl(@NotNull ConfigurationSection section, MessageVerifier verifier) {
+        this.section = section;
+        this.verifier = verifier;
     }
 
     public MessagesImpl(@NotNull File file) {
         this(YamlConfiguration.loadConfiguration(file));
     }
 
+    public MessagesImpl(@NotNull File file, MessageVerifier verifier) {
+        this(YamlConfiguration.loadConfiguration(file));
+        this.verifier = verifier;
+    }
+
+
+
     @Override
     public Message get(String key) {
-        return messages.get(key);
+        if(!has(key)) {
+            if(verifier != null) {
+                Optional<Object> def = verifier.fromDefault(key);
+                if(def.isPresent()) {
+                    if(def.get() instanceof List) messages.put(key, factory.message((List<String>) def.get()));
+                    else messages.put(key, factory.message((def.get().toString())));
+                    return messages.get(key);
+                }
+                return NULL_MESSAGE;
+            }
+            return NULL_MESSAGE;
+        }
+        return messages.get(key) == null ? NULL_MESSAGE : messages.get(key);
     }
 
     @Override
     public Message put(String key, Message message) {
-        if(!has(key)) return NULL_MESSAGE;
         return messages.put(key, message);
     }
 
@@ -52,8 +79,15 @@ public class MessagesImpl implements Messages {
     }
 
     @Override
-    public void factory(MessageFactory messageFactory) {
+    public Messages factory(MessageFactory messageFactory) {
         this.factory = messageFactory;
+        return this;
+    }
+
+    @Override
+    public Messages init() {
+        messages = fromConfigurationToMap(section);
+        return this;
     }
 
     private Map<String, Message> fromConfigurationToMap(@NotNull ConfigurationSection section) {

src/main/java/me/redtea/nodropx/libs/message/model/AbstractMessage.java

@@ -38,7 +38,6 @@ public abstract class AbstractMessage implements Message {
         parse();
         Audience audience = adventure.sender(sender);
         parsed.forEach(audience::sendMessage);
-
     }
 
     private Component cacheComponent = null;

src/main/java/me/redtea/nodropx/libs/message/model/Message.java

@@ -1,7 +1,9 @@
 package me.redtea.nodropx.libs.message.model;
 
+import me.redtea.nodropx.util.MaterialUtils;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.ComponentLike;
+import org.bukkit.Material;
 import org.bukkit.command.CommandSender;
 import org.jetbrains.annotations.NotNull;
 
@@ -60,4 +62,8 @@ public interface Message extends ComponentLike {
     default Message replaceAll(@NotNull Object from, @NotNull Object to) {
         return replaceAll(String.valueOf(from), String.valueOf(to));
     }
+
+    default Material toMaterial() {
+        return Material.matchMaterial(asUnparsedString()) == null ? Material.STONE : Material.matchMaterial(asUnparsedString());
+    }
 }

src/main/java/me/redtea/nodropx/libs/message/model/impl/ComponentMessage.java

@@ -7,7 +7,7 @@ import net.kyori.adventure.text.minimessage.MiniMessage;
 import java.util.List;
 
 public class ComponentMessage extends AbstractMessage {
-    private final MiniMessage mm = MiniMessage.get();
+    private final MiniMessage mm = MiniMessage.builder().build();
 
     public ComponentMessage(List<String> unparsed) {
         super(unparsed);

src/main/java/me/redtea/nodropx/libs/message/verifier/MessageVerifier.java

@@ -0,0 +1,7 @@
+package me.redtea.nodropx.libs.message.verifier;
+
+import java.util.Optional;
+
+public interface MessageVerifier {
+    Optional<Object> fromDefault(String key);
+}

src/main/java/me/redtea/nodropx/libs/message/verifier/impl/FileMessageVerifier.java

@@ -0,0 +1,39 @@
+package me.redtea.nodropx.libs.message.verifier.impl;
+
+import lombok.SneakyThrows;
+import me.redtea.nodropx.libs.message.verifier.MessageVerifier;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.List;
+import java.util.Optional;
+
+public class FileMessageVerifier implements MessageVerifier {
+    private ConfigurationSection defaultSection;
+
+    private final FileConfiguration toSaveSection;
+    private final File toSaveFile;
+
+    public FileMessageVerifier(InputStream defaultResource, FileConfiguration toSaveSection, File toSaveFile) {
+        defaultSection = YamlConfiguration.loadConfiguration(new InputStreamReader(defaultResource));
+        this.toSaveSection = toSaveSection;
+        this.toSaveFile = toSaveFile;
+    }
+
+    @Override
+    public Optional<Object> fromDefault(String key) {
+        Optional<Object> o = Optional.ofNullable(defaultSection.get(key));
+        o.ifPresent(s -> saveToMain(key, s));
+        return o;
+    }
+
+    @SneakyThrows
+    public void saveToMain(String path, Object obj) {
+        toSaveSection.set(path, obj);
+        toSaveSection.save(toSaveFile);
+    }
+}

src/main/java/me/redtea/nodropx/listener/ConfirmDropHandler.java

@@ -0,0 +1,22 @@
+package me.redtea.nodropx.listener;
+
+import lombok.RequiredArgsConstructor;
+import me.redtea.nodropx.api.event.NoDropItemThrownEvent;
+import me.redtea.nodropx.menu.facade.MenuFacade;
+import me.redtea.nodropx.service.dropconfirm.DropConfirmService;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+
+@RequiredArgsConstructor
+public class ConfirmDropHandler implements Listener {
+    private final DropConfirmService confirmService;
+    private final MenuFacade menuFacade;
+
+    @EventHandler
+    public void onDrop(NoDropItemThrownEvent event) {
+        if(!confirmService.isConfirmed(event.getPlayer()) && event.getReason() == NoDropItemThrownEvent.Reason.DROP_BY_PLAYER) {
+            menuFacade.openConfirmDrop(event.getPlayer());
+            event.setCancelled(true);
+        } else confirmService.resetConfirm(event.getPlayer());
+    }
+}

src/main/java/me/redtea/nodropx/listener/InventoryHandler.java

@@ -1,8 +1,12 @@
 package me.redtea.nodropx.listener;
 
+import com.google.common.collect.Lists;
 import lombok.RequiredArgsConstructor;
 import me.redtea.nodropx.api.event.NoDropItemThrownEvent;
+import me.redtea.nodropx.service.dropconfirm.DropConfirmService;
+import me.redtea.nodropx.service.dropconfirm.impl.DropConfirmNull;
 import me.redtea.nodropx.service.event.EventService;
+import me.redtea.nodropx.service.nodrop.NoDropService;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
@@ -10,22 +14,32 @@ import org.bukkit.event.inventory.InventoryAction;
 import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.inventory.ItemStack;
 
+import java.util.List;
 import java.util.Optional;
 
 @RequiredArgsConstructor
 public class InventoryHandler implements Listener {
     private final EventService eventService;
+    private final NoDropService noDropService;
+    private final DropConfirmService dropConfirmService;
+
 
     @EventHandler
     public void onMove(InventoryClickEvent event) {
-        if(event.getAction().equals(InventoryAction.MOVE_TO_OTHER_INVENTORY)) {
+        if(event.getAction().name().startsWith("DROP")
+                && (noDropService.isNoDrop(event.getCursor()) || noDropService.isNoDrop(event.getCurrentItem()))
+                && !(dropConfirmService instanceof DropConfirmNull)) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if(event.getAction().equals(InventoryAction.MOVE_TO_OTHER_INVENTORY) && !event.getInventory().equals(event.getClickedInventory())) {
             call(event, event.getCurrentItem());
         } else if(event.getAction().equals(InventoryAction.PLACE_ALL)
         || event.getAction().equals(InventoryAction.PLACE_ONE)
         || event.getAction().equals(InventoryAction.PLACE_SOME)) {
             call(event, event.getCursor());
         }
-
     }
 
     private void call(InventoryClickEvent event, ItemStack item) {

src/main/java/me/redtea/nodropx/listener/PlayerHandler.java

@@ -2,8 +2,9 @@ package me.redtea.nodropx.listener;
 
 import lombok.RequiredArgsConstructor;
 import me.redtea.nodropx.api.event.NoDropItemThrownEvent;
-import me.redtea.nodropx.gui.facade.GuiFacade;
+import me.redtea.nodropx.menu.facade.MenuFacade;
 import me.redtea.nodropx.service.event.EventService;
+import me.redtea.nodropx.service.nodrop.NoDropService;
 import me.redtea.nodropx.service.respawn.RespawnService;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
@@ -19,9 +20,8 @@ import java.util.Optional;
 public class PlayerHandler implements Listener {
     private final RespawnService respawnService;
     private final EventService eventService;
-    private final GuiFacade guiFacade;
+    private final MenuFacade menuFacade;
 
-    //TODO check for armor
     @EventHandler
     public void onDrop(PlayerDropItemEvent event) {
         eventService.callThrownEvent(
@@ -44,7 +44,7 @@ public class PlayerHandler implements Listener {
 
     @EventHandler
     public void onQuit(PlayerQuitEvent event) {
-        guiFacade.clearCache(event.getPlayer());
+        menuFacade.clearCache(event.getPlayer());
     }
 
 }

src/main/java/me/redtea/nodropx/listener/menu/SinglePageGuiHandler.java

@@ -0,0 +1,40 @@
+package me.redtea.nodropx.listener.menu;
+
+import me.redtea.nodropx.menu.storage.singlepage.SinglePageController;
+import me.redtea.nodropx.menu.storage.singlepage.SinglePageGui;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryAction;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+
+public class SinglePageGuiHandler implements Listener {
+    private final SinglePageController controller;
+    private final SinglePageGui gui;
+
+    public SinglePageGuiHandler(SinglePageController controller, SinglePageGui gui) {
+        this.controller = controller;
+        this.gui = gui;
+
+    }
+
+
+    @EventHandler
+    public void onClick(InventoryClickEvent event) {
+        if(gui.isStorageGui(event.getInventory())) {
+            if(event.getAction() == InventoryAction.MOVE_TO_OTHER_INVENTORY) controller.onClick(event);
+        }
+        if(gui.isStorageGui(event.getClickedInventory()) && event.getWhoClicked() instanceof Player) {
+            controller.onClick(event);
+        }
+    }
+
+    @EventHandler
+    public void onClose(InventoryCloseEvent event) {
+        if(gui.isStorageGui(event.getInventory()) && event.getPlayer() instanceof Player) {
+            controller.onClose(event);
+        }
+    }
+
+}

src/main/java/me/redtea/nodropx/menu/CachedMenu.java

@@ -0,0 +1,8 @@
+package me.redtea.nodropx.menu;
+
+import org.bukkit.entity.Player;
+
+public interface CachedMenu extends Menu {
+    void clearCache(Player player);
+    void clearAllCache();
+}

src/main/java/me/redtea/nodropx/menu/Menu.java

@@ -0,0 +1,7 @@
+package me.redtea.nodropx.menu;
+
+import org.bukkit.entity.Player;
+
+public interface Menu {
+    void open(Player player);
+}

src/main/java/me/redtea/nodropx/menu/dropconfirm/DropConfirmMFGui.java

@@ -0,0 +1,38 @@
+package me.redtea.nodropx.menu.dropconfirm;
+
+import dev.triumphteam.gui.builder.item.ItemBuilder;
+import dev.triumphteam.gui.guis.Gui;
+import me.redtea.nodropx.libs.message.container.Messages;
+import me.redtea.nodropx.menu.Menu;
+import me.redtea.nodropx.service.dropconfirm.DropConfirmService;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+
+public class DropConfirmMFGui implements Menu {
+    private final Gui gui;
+    public DropConfirmMFGui(Messages messages, DropConfirmService dropConfirmService) {
+        gui = Gui.gui()
+                .rows(1)
+                .title(messages.get("gui.confirm.title").asComponent())
+                .disableAllInteractions()
+                .create();
+        gui.setItem(1, ItemBuilder.from(messages.get("gui.confirm.yesButton.material").toMaterial())
+                .name(messages.get("gui.confirm.yesButton.name").asComponent())
+                .lore(messages.get("gui.confirm.yesButton.lore").asComponent())
+                .asGuiItem((event -> {
+                    dropConfirmService.confirm((Player) event.getWhoClicked());
+                    event.getWhoClicked().dropItem(true);
+                    event.getWhoClicked().closeInventory();
+                })));
+        gui.setItem(7, ItemBuilder.from(messages.get("gui.confirm.noButton.material").toMaterial())
+                .name(messages.get("gui.confirm.noButton.name").asComponent())
+                .lore(messages.get("gui.confirm.noButton.lore").asComponent())
+                .asGuiItem((event -> event.getWhoClicked().closeInventory())));
+    }
+
+    @Override
+    public void open(Player player) {
+        gui.open(player);
+    }
+}

src/main/java/me/redtea/nodropx/menu/facade/MenuFacade.java

@@ -0,0 +1,12 @@
+package me.redtea.nodropx.menu.facade;
+
+import me.redtea.nodropx.menu.CachedMenu;
+import org.bukkit.entity.Player;
+
+public interface MenuFacade {
+    CachedMenu noDropStorage();
+    void openPersonalStorage(Player player);
+    void openConfirmDrop(Player player);
+    void clearCache(Player player);
+    void clearAllCache();
+}

src/main/java/me/redtea/nodropx/menu/facade/impl/MenuFacadeImpl.java

@@ -0,0 +1,38 @@
+package me.redtea.nodropx.menu.facade.impl;
+
+import lombok.RequiredArgsConstructor;
+import me.redtea.nodropx.menu.CachedMenu;
+import me.redtea.nodropx.menu.Menu;
+import me.redtea.nodropx.menu.facade.MenuFacade;
+import org.bukkit.entity.Player;
+
+@RequiredArgsConstructor
+public class MenuFacadeImpl implements MenuFacade {
+    private final CachedMenu personalStorageCachedMenu;
+    private final Menu confirmDropMenu;
+
+    @Override
+    public CachedMenu noDropStorage() {
+        return personalStorageCachedMenu;
+    }
+
+    @Override
+    public void openPersonalStorage(Player player) {
+        personalStorageCachedMenu.open(player);
+    }
+
+    @Override
+    public void openConfirmDrop(Player player) {
+        confirmDropMenu.open(player);
+    }
+
+    @Override
+    public void clearCache(Player player) {
+        personalStorageCachedMenu.clearCache(player);
+    }
+
+    @Override
+    public void clearAllCache() {
+        personalStorageCachedMenu.clearAllCache();
+    }
+}

src/main/java/me/redtea/nodropx/menu/storage/pages/MFPageGui.java

@@ -1,14 +1,16 @@
-package me.redtea.nodropx.gui.pages;
+package me.redtea.nodropx.menu.storage.pages;
 
 import dev.triumphteam.gui.builder.item.ItemBuilder;
 import dev.triumphteam.gui.guis.Gui;
 import dev.triumphteam.gui.guis.GuiItem;
 import dev.triumphteam.gui.guis.ScrollingGui;
 import lombok.RequiredArgsConstructor;
+import me.redtea.nodropx.menu.CachedMenu;
 import me.redtea.nodropx.libs.carcadex.repo.MutableRepo;
 import me.redtea.nodropx.libs.message.container.Messages;
+import me.redtea.nodropx.service.material.ItemStackService;
 import me.redtea.nodropx.service.nodrop.NoDropService;
-import me.redtea.nodropx.util.MaterialUtils;
+import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.event.inventory.InventoryAction;
@@ -21,13 +23,15 @@ import java.util.*;
 import java.util.stream.Collectors;
 
 @RequiredArgsConstructor
-public class StorageGui {
-    private final Map<UUID, ScrollingGui> cache = new HashMap<>();
+public class MFPageGui implements CachedMenu {
     private final Messages messages;
-    private final MutableRepo<UUID, List<ItemStack>> pagesRepo;
+    private final MutableRepo<UUID, List<ItemStack>> personalStorageRepo;
     private final NoDropService noDropService;
+    private final ItemStackService itemStackService;
     private final Plugin plugin;
 
+    private final Map<UUID, ScrollingGui> cache = new HashMap<>();
+
     public void open(Player player) {
         if(cache.containsKey(player.getUniqueId())) {
             cache.get(player.getUniqueId()).open(player);
@@ -35,7 +39,7 @@ public class StorageGui {
         }
 
         ScrollingGui gui = Gui.scrolling()
-                .title(messages.get("gui.title").asComponent())
+                .title(messages.get("gui.personalStorage.title").asComponent())
                 .rows(6)
                 .pageSize(45)
                 .disableAllInteractions()
@@ -44,16 +48,16 @@ public class StorageGui {
         setButtons(gui);
         setAction(gui);
         setOnClose(gui);
-        for(ItemStack item : pagesRepo.get(player.getUniqueId()).orElse(new ArrayList<>())) {
+        for(ItemStack item : personalStorageRepo.get(player.getUniqueId()).orElse(new ArrayList<>())) {
             gui.addItem(ItemBuilder.from(item).asGuiItem());
         }
 
-        gui.open(player);
         cache.put(player.getUniqueId(), gui);
+        gui.open(player);
     }
 
     private void setOnClose(ScrollingGui gui) {
-        gui.setCloseGuiAction(event -> pagesRepo.update(event.getPlayer().getUniqueId(), gui.getPageItems().stream()
+        gui.setCloseGuiAction(event -> personalStorageRepo.update(event.getPlayer().getUniqueId(), gui.getPageItems().stream()
                 .map(GuiItem::getItemStack)
                 .collect(Collectors.toList())));
     }
@@ -108,21 +112,21 @@ public class StorageGui {
     private void setFrame(ScrollingGui gui) {
         for(int i = 1; i < 10; ++i) {
             gui.setItem(6, i, ItemBuilder.from(
-                    MaterialUtils.getMaterialFromString(messages.get("gui.frame.material").asUnparsedString())
-            ).name(messages.get("gui.frame.name").asComponent()).asGuiItem(event -> event.setCancelled(true)));
+                    itemStackService.get(messages.get("gui.personalStorage.frame.material").asUnparsedString(), 1)
+            ).name(messages.get("gui.personalStorage.frame.name").asComponent()).asGuiItem(event -> event.setCancelled(true)));
         }
     }
 
     private void setButtons(ScrollingGui gui) {
         gui.setItem(6, 3, ItemBuilder.from(
-                MaterialUtils.getMaterialFromString(messages.get("gui.prev.material").asUnparsedString())
-        ).name(messages.get("gui.prev.name").asComponent()).asGuiItem(event -> {
+                itemStackService.get(messages.get("gui.personalStorage.prev.material").asUnparsedString(), 1)
+        ).name(messages.get("gui.personalStorage.prev.name").asComponent()).asGuiItem(event -> {
             gui.previous();
             event.setCancelled(true);
         }));
         gui.setItem(6, 7, ItemBuilder.from(
-                MaterialUtils.getMaterialFromString(messages.get("gui.next.material").asUnparsedString())
-        ).name(messages.get("gui.next.name").asComponent()).asGuiItem(event -> {
+                itemStackService.get(messages.get("gui.personalStorage.next.material").asUnparsedString(), 1)
+        ).name(messages.get("gui.personalStorage.next.name").asComponent()).asGuiItem(event -> {
             gui.next();
             event.setCancelled(true);
         }));
@@ -133,6 +137,10 @@ public class StorageGui {
     }
 
     public void clearAllCache() {
+        cache.forEach((k, v) -> {
+            Player player = Bukkit.getPlayer(k);
+            if(player != null) v.close(player);
+        });
         cache.clear();
     }
 

src/main/java/me/redtea/nodropx/menu/storage/singlepage/SinglePageController.java

@@ -0,0 +1,50 @@
+package me.redtea.nodropx.menu.storage.singlepage;
+
+import com.google.common.collect.Lists;
+import lombok.RequiredArgsConstructor;
+import me.redtea.nodropx.libs.carcadex.repo.MutableRepo;
+import me.redtea.nodropx.service.nodrop.NoDropService;
+import me.redtea.nodropx.util.FoliaSupportedUtils;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.InventoryAction;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.UUID;
+
+@RequiredArgsConstructor
+public class SinglePageController {
+    private final NoDropService noDropService;
+    private final SinglePageGui singlePageGui;
+    private final MutableRepo<UUID, List<ItemStack>> personalStorageRepo;
+    private final FoliaSupportedUtils foliaSupportedUtils;
+
+    private final List<InventoryAction> clickActions = Lists.newArrayList(InventoryAction.MOVE_TO_OTHER_INVENTORY, InventoryAction.PLACE_ALL, InventoryAction.PLACE_ONE, InventoryAction.PLACE_SOME,
+            InventoryAction.SWAP_WITH_CURSOR, InventoryAction.NOTHING, InventoryAction.COLLECT_TO_CURSOR, InventoryAction.HOTBAR_MOVE_AND_READD, InventoryAction.UNKNOWN);
+
+
+    public void onClick(InventoryClickEvent event) {
+        if(clickActions.contains(event.getAction()) && !(noDropService.isNoDrop(event.getCurrentItem()))) {
+            event.setCancelled(true);
+        }
+        foliaSupportedUtils.runTask(() -> {
+            for(ItemStack itemStack : event.getInventory()) {
+                if (itemStack != null && !noDropService.isNoDrop(itemStack)) {
+                    event.getWhoClicked().getInventory().addItem(itemStack);
+                    event.getInventory().remove(itemStack);
+                    ((Player) event.getWhoClicked()).updateInventory();
+                }
+            }
+        });
+
+    }
+
+    public void onClose(InventoryCloseEvent event) {
+        Player player = (Player) event.getPlayer();
+        personalStorageRepo.update(event.getPlayer().getUniqueId(),
+                Arrays.asList(singlePageGui.getCache().get(player.getUniqueId()).getContents()));
+    }
+}

src/main/java/me/redtea/nodropx/menu/storage/singlepage/SinglePageGui.java

@@ -0,0 +1,46 @@
+package me.redtea.nodropx.menu.storage.singlepage;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import me.redtea.nodropx.libs.carcadex.repo.MutableRepo;
+import me.redtea.nodropx.libs.message.container.Messages;
+import me.redtea.nodropx.menu.CachedMenu;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.*;
+
+@RequiredArgsConstructor
+public class SinglePageGui implements CachedMenu {
+    private final Messages messages;
+    private final MutableRepo<UUID, List<ItemStack>> personalStorageRepo;
+    @Getter
+    private final Map<UUID, Inventory> cache = new HashMap<>();
+
+    @Override
+    public void open(Player player) {
+        if(cache.containsKey(player.getUniqueId())) {
+            player.openInventory(cache.get(player.getUniqueId()));
+            return;
+        }
+        Inventory gui = Bukkit.createInventory(null, 54, messages.get("gui.personalStorage.title").asComponent());
+        for(ItemStack item : personalStorageRepo.get(player.getUniqueId()).orElse(new ArrayList<>())) if(item != null) gui.addItem(item);
+
+        cache.put(player.getUniqueId(), gui);
+        player.openInventory(gui);
+    }
+
+    public void clearCache(Player player) {
+        cache.remove(player.getUniqueId());
+    }
+
+    public void clearAllCache() {
+        cache.clear();
+    }
+
+    public boolean isStorageGui(Inventory inventory) {
+        return cache.containsValue(inventory);
+    }
+}

src/main/java/me/redtea/nodropx/model/cosmetic/impl/LoreKyoriCosmetic.java

@@ -12,7 +12,7 @@ import java.util.stream.Collectors;
 
 public class LoreKyoriCosmetic implements CosmeticStrategy {
     private List<Component> lore;
-    private final MiniMessage mm = MiniMessage.get();
+    private final MiniMessage mm = MiniMessage.builder().build();
     @Override
     public void apply(ItemStack itemStack) {
         List<Component> lore = itemStack.lore();

src/main/java/me/redtea/nodropx/model/materialprovider/ItemStackProvider.java

@@ -0,0 +1,10 @@
+package me.redtea.nodropx.model.materialprovider;
+
+import org.bukkit.inventory.ItemStack;
+
+import java.util.List;
+
+public interface ItemStackProvider {
+        ItemStack get(String s);
+        List<String> allMaterials();
+}

src/main/java/me/redtea/nodropx/model/materialprovider/impl/ItemStackProviderDefault.java

@@ -0,0 +1,36 @@
+package me.redtea.nodropx.model.materialprovider.impl;
+
+import me.redtea.nodropx.model.materialprovider.ItemStackProvider;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ItemStackProviderDefault implements ItemStackProvider {
+    @Override
+    public ItemStack get(String s) {
+        if(s == null || s.equals("")) return new ItemStack(Material.AIR);
+        Material material = Material.matchMaterial(s);
+        if(material != null) return new ItemStack(material);
+
+        String[] spl = s.split(":");
+
+        if (spl[0].equals("minecraft")) {
+            material = Material.matchMaterial(spl[1]);
+        } else {
+            if(spl.length < 2) {
+                material = Material.matchMaterial(spl[0]);
+            } else {
+                material = Material.matchMaterial(spl[0]+"_"+spl[1]);;
+            }
+        }
+        return new ItemStack(material == null ? Material.AIR : material);
+    }
+
+    @Override
+    public List<String> allMaterials() {
+        return Arrays.stream(Material.values()).map(Enum::name).collect(Collectors.toList());
+    }
+}

src/main/java/me/redtea/nodropx/model/materialprovider/impl/ItemsAdderProvider.java

@@ -0,0 +1,21 @@
+package me.redtea.nodropx.model.materialprovider.impl;
+
+import dev.lone.itemsadder.api.CustomStack;
+import dev.lone.itemsadder.api.ItemsAdder;
+import me.redtea.nodropx.model.materialprovider.ItemStackProvider;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ItemsAdderProvider implements ItemStackProvider {
+    @Override
+    public ItemStack get(String s) {
+        return CustomStack.getInstance(s).getItemStack();
+    }
+
+    @Override
+    public List<String> allMaterials() {
+        return ItemsAdder.getAllItems().stream().map(CustomStack::getNamespacedID).collect(Collectors.toList());
+    }
+}

src/main/java/me/redtea/nodropx/service/capasity/CapacityService.java

@@ -0,0 +1,21 @@
+package me.redtea.nodropx.service.capasity;
+
+import me.redtea.nodropx.libs.carcadex.repo.Repo;
+import me.redtea.nodropx.libs.carcadex.repo.impl.yaml.YamlRepo;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+import java.io.File;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public interface CapacityService {
+
+
+    List<Integer> get(ItemStack item);
+    void reload();
+
+    default List<Integer> get(Material material) {
+        return get(new ItemStack(material));
+    }
+}

src/main/java/me/redtea/nodropx/service/capasity/impl/CapacityServiceImpl.java

@@ -0,0 +1,52 @@
+package me.redtea.nodropx.service.capasity.impl;
+
+import me.redtea.nodropx.libs.carcadex.repo.Repo;
+import me.redtea.nodropx.libs.carcadex.repo.impl.yaml.YamlRepo;
+import me.redtea.nodropx.service.capasity.CapacityService;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+
+import java.io.File;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class CapacityServiceImpl implements CapacityService {
+    private final Repo<String, List<Integer>> capacityRepo;
+    private final Map<String, Integer> customModelDataRequired = new HashMap<>();
+    public CapacityServiceImpl(Plugin plugin) {
+        capacityRepo = new YamlRepo<>(
+                new File(plugin.getDataFolder(), "capacity.yml").toPath(),
+                plugin,
+                conf -> conf.getKeys(false).stream().collect(Collectors.toMap(
+                        value -> {
+                            if(value.contains("->")) {
+                                String[] args = value.split("->");
+                                customModelDataRequired.put(args[0], Integer.parseInt(args[1]));
+                                return args[0];
+                            } else return value;
+                        },
+                        conf::getIntegerList))
+        );
+    }
+
+    @Override
+    public List<Integer> get(ItemStack item) {
+        String key = item.getType().name();
+        Optional<List<Integer>> result = capacityRepo.get(key);
+        if(!result.isPresent()) {
+            return Collections.emptyList();
+        }
+        if(customModelDataRequired.containsKey(key)) {
+            int cmi = customModelDataRequired.get(key);
+            if(!item.getItemMeta().hasCustomModelData() || item.getItemMeta().getCustomModelData() != cmi) {
+                return Collections.emptyList();
+            }
+        }
+        return result.get();
+    }
+
+    @Override
+    public void reload() {
+        capacityRepo.reload();
+    }
+}

src/main/java/me/redtea/nodropx/service/dropconfirm/DropConfirmService.java

@@ -0,0 +1,9 @@
+package me.redtea.nodropx.service.dropconfirm;
+
+import org.bukkit.entity.Player;
+
+public interface DropConfirmService {
+    boolean isConfirmed(Player player);
+    void confirm(Player player);
+    void resetConfirm(Player player);
+}

src/main/java/me/redtea/nodropx/service/dropconfirm/impl/DropConfirmNull.java

@@ -0,0 +1,21 @@
+package me.redtea.nodropx.service.dropconfirm.impl;
+
+import me.redtea.nodropx.service.dropconfirm.DropConfirmService;
+import org.bukkit.entity.Player;
+
+public class DropConfirmNull implements DropConfirmService {
+    @Override
+    public boolean isConfirmed(Player player) {
+        return true;
+    }
+
+    @Override
+    public void confirm(Player player) {
+
+    }
+
+    @Override
+    public void resetConfirm(Player player) {
+
+    }
+}

src/main/java/me/redtea/nodropx/service/dropconfirm/impl/DropConfirmServiceImpl.java

@@ -0,0 +1,27 @@
+package me.redtea.nodropx.service.dropconfirm.impl;
+
+import me.redtea.nodropx.service.dropconfirm.DropConfirmService;
+import org.bukkit.entity.Player;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+public class DropConfirmServiceImpl implements DropConfirmService {
+    private Set<UUID> confirmed = new HashSet<>();
+    @Override
+    public boolean isConfirmed(Player player) {
+        return confirmed.contains(player.getUniqueId());
+    }
+
+    @Override
+    public void confirm(Player player) {
+        confirmed.add(player.getUniqueId());
+    }
+
+    @Override
+    public void resetConfirm(Player player) {
+        confirmed.remove(player.getUniqueId());
+    }
+
+}

src/main/java/me/redtea/nodropx/service/material/ItemStackService.java

@@ -0,0 +1,16 @@
+package me.redtea.nodropx.service.material;
+
+import me.redtea.nodropx.model.materialprovider.ItemStackProvider;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public interface ItemStackService {
+    @NotNull
+    ItemStack get(String s, int amount);
+
+    void registerProvider(ItemStackProvider provider);
+
+    List<String> allMaterials();
+}

src/main/java/me/redtea/nodropx/service/material/impl/ItemStackServiceImpl.java

@@ -0,0 +1,42 @@
+package me.redtea.nodropx.service.material.impl;
+
+import lombok.val;
+import me.redtea.nodropx.model.materialprovider.ItemStackProvider;
+import me.redtea.nodropx.service.material.ItemStackService;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ItemStackServiceImpl implements ItemStackService {
+    private final List<ItemStackProvider> providers = new ArrayList<>();
+
+    @Override
+    public @NotNull ItemStack get(String s, int amount) {
+        ItemStack result = new ItemStack(Material.AIR);
+        for(ItemStackProvider provider : providers) {
+            val i = provider.get(s);
+            if(i != null && i.getType() != Material.AIR) {
+                result = i;
+                break;
+            }
+        }
+        result.setAmount(amount);
+        return result;
+    }
+
+    @Override
+    public void registerProvider(ItemStackProvider provider) {
+        providers.add(provider);
+    }
+
+    private List<String> materials = null;
+    @Override
+    public List<String> allMaterials() {
+        if(materials == null) materials = providers.stream().map(ItemStackProvider::allMaterials).flatMap(List::stream).collect(Collectors.toList());
+        return materials;
+    }
+}

src/main/java/me/redtea/nodropx/service/respawn/impl/NullRespawnService.java

@@ -0,0 +1,17 @@
+package me.redtea.nodropx.service.respawn.impl;
+
+import me.redtea.nodropx.service.respawn.RespawnService;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.PlayerDeathEvent;
+
+public class NullRespawnService implements RespawnService {
+    @Override
+    public void giveSavedItems(Player player) {
+
+    }
+
+    @Override
+    public void saveItemsBeforeDeath(PlayerDeathEvent event) {
+
+    }
+}

src/main/java/me/redtea/nodropx/service/respawn/impl/RespawnServiceImpl.java

@@ -1,9 +1,12 @@
 package me.redtea.nodropx.service.respawn.impl;
 
 import lombok.AllArgsConstructor;
+import lombok.Data;
 import lombok.RequiredArgsConstructor;
+import lombok.ToString;
 import me.redtea.nodropx.api.event.NoDropItemDropOnDeathEvent;
 import me.redtea.nodropx.libs.carcadex.repo.Repo;
+import me.redtea.nodropx.service.capasity.CapacityService;
 import me.redtea.nodropx.service.nodrop.NoDropService;
 import me.redtea.nodropx.service.respawn.RespawnService;
 import org.bukkit.Bukkit;
@@ -12,12 +15,13 @@ import org.bukkit.event.entity.PlayerDeathEvent;
 import org.bukkit.inventory.ItemStack;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 @RequiredArgsConstructor
 public class RespawnServiceImpl implements RespawnService {
     private final NoDropService noDropService;
     private final Map<String, Pair[]> toRespawn = new HashMap<>();
-    private final Repo<String, List<Integer>> capacity;
+    private final CapacityService capacityService;
 
 
     @Override
@@ -25,7 +29,9 @@ public class RespawnServiceImpl implements RespawnService {
         if(toRespawn.containsKey(player.getName())) {
             Pair[] pairs = toRespawn.get(player.getName());
             for(Pair pair : pairs) player.getInventory().setItem(pair.slot, pair.item);
+            toRespawn.remove(player.getName());
         }
+        player.updateInventory();
     }
 
     @Override
@@ -59,12 +65,13 @@ public class RespawnServiceImpl implements RespawnService {
     }
 
     @AllArgsConstructor
+    @ToString
     static class Pair {
         int slot;
         ItemStack item;
     }
 
     private List<Integer> getProtectedSlots(ItemStack i) {
-        return capacity.get(i.getType().name()).orElse(new ArrayList<>());
+        return capacityService.get(i);
     }
 }

src/main/java/me/redtea/nodropx/service/storage/impl/StorageServiceImpl.java

@@ -1,7 +1,7 @@
 package me.redtea.nodropx.service.storage.impl;
 
 import lombok.RequiredArgsConstructor;
-import me.redtea.nodropx.gui.facade.GuiFacade;
+import me.redtea.nodropx.menu.facade.MenuFacade;
 import me.redtea.nodropx.libs.carcadex.repo.MutableRepo;
 import me.redtea.nodropx.service.nodrop.NoDropService;
 import me.redtea.nodropx.service.storage.StorageService;
@@ -14,17 +14,17 @@ import java.util.UUID;
 
 @RequiredArgsConstructor
 public class StorageServiceImpl implements StorageService {
-    private final GuiFacade guiFacade;
+    private final MenuFacade menuFacade;
     private final MutableRepo<UUID, List<ItemStack>> pagesRepo;
     private final NoDropService noDropService;
 
     @Override
     public void addItem(UUID playerId, ItemStack item) {
-        List<ItemStack> items = pagesRepo.get(playerId).orElse(new ArrayList<>());
+        List<ItemStack> items = new ArrayList<>(pagesRepo.get(playerId).orElse(new ArrayList<>()));
         if(!noDropService.isNoDrop(item)) throw new IllegalArgumentException("Item must be no drop!");
         items.add(item);
         pagesRepo.update(playerId, items);
-        guiFacade.clearCache(Bukkit.getPlayer(playerId));
+        menuFacade.clearCache(Bukkit.getPlayer(playerId));
     }
 
     @Override
@@ -33,7 +33,7 @@ public class StorageServiceImpl implements StorageService {
         if(items == null) return;
         items.remove(item);
         pagesRepo.update(playerId, items);
-        guiFacade.clearCache(Bukkit.getPlayer(playerId));
+        menuFacade.clearCache(Bukkit.getPlayer(playerId));
     }
 
     @Override

src/main/java/me/redtea/nodropx/util/ConfigVerifier.java

@@ -0,0 +1,37 @@
+package me.redtea.nodropx.util;
+
+import org.bukkit.configuration.Configuration;
+import org.bukkit.configuration.MemoryConfiguration;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.plugin.Plugin;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/*
+    Verify for versions:
+    - 1.0.2
+    - 1.0.3
+     */
+public class ConfigVerifier {
+    public void verifyDefaults(Plugin plugin) {
+        Map<String, Object> properties = new HashMap<String, Object>(){{
+            put("forceUseLegacy", false);
+            put("forceUseMD5Colors", false);
+
+            //1.0.3
+            put("checkForUpdates", true);
+            put("personalStorageType", "SINGLE_PAGE");
+            put("confirmThrowNoDropItem", true);
+            put("forceUseFoliaPatches", false);
+        }};
+
+        plugin.saveDefaultConfig();
+        FileConfiguration config = plugin.getConfig();
+        for(Map.Entry<String, Object> entry : properties.entrySet()) {
+            if(!config.contains(entry.getKey(), true))
+                plugin.getConfig().set(entry.getKey(), entry.getValue());
+        }
+        plugin.saveConfig();
+    }
+}

src/main/java/me/redtea/nodropx/util/FoliaSupportedUtils.java

@@ -0,0 +1,18 @@
+package me.redtea.nodropx.util;
+
+import lombok.RequiredArgsConstructor;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+
+@RequiredArgsConstructor
+public class FoliaSupportedUtils {
+    private final Plugin plugin;
+
+    public void runTask(Runnable runnable) {
+        try {
+            Bukkit.getScheduler().runTask(plugin, runnable);
+        } catch (UnsupportedOperationException e) {
+            new Thread(runnable).start();
+        }
+    }
+}

src/main/java/me/redtea/nodropx/util/MaterialUtils.java

@@ -7,28 +7,7 @@ import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
 
 public class MaterialUtils {
-    @NotNull
-    public static Material getMaterialFromString(String s) {
-        if(s == null || s.equals("")) return Material.AIR;
-        Material material = Material.matchMaterial(s);
-        if(material != null) return material;
-
-        String[] spl = s.split(":");
-
-        if (spl[0].equals("minecraft")) {
-            material = Material.matchMaterial(spl[1]);
-        } else {
-            if(spl.length < 2) {
-                material = Material.matchMaterial(spl[0]);
-            } else {
-                material = Material.matchMaterial(spl[0]+"_"+spl[1]);;
-            }
-        }
-
-        return  material == null ? Material.AIR : material;
-    }
-
-    public void remove(Inventory inventory, Material type, int amount) {
+    public static void remove(Inventory inventory, Material type, int amount) {
         if (amount <= 0) return;
         int size = inventory.getSize();
         for (int slot = 0; slot < size; slot++) {

src/main/java/me/redtea/nodropx/util/UpdateChecker.java

@@ -0,0 +1,38 @@
+package me.redtea.nodropx.util;
+
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Scanner;
+import java.util.function.Consumer;
+
+public class UpdateChecker {
+    private final JavaPlugin plugin;
+    private final int resourceId;
+    private final FoliaSupportedUtils foliaSupportedUtils;
+
+
+    public UpdateChecker(JavaPlugin plugin, int resourceId, FoliaSupportedUtils foliaSupportedUtils) {
+        this.plugin = plugin;
+        this.resourceId = resourceId;
+
+        this.foliaSupportedUtils = foliaSupportedUtils;
+    }
+
+
+    public void getVersion(final Consumer<String> consumer) {
+        foliaSupportedUtils.runTask(() -> {
+            try (InputStream is = new URL("https://api.spigotmc.org/legacy/update.php?resource=" + this.resourceId).openStream(); Scanner scann = new Scanner(is)) {
+                if (scann.hasNext()) {
+                    consumer.accept(scann.next());
+                }
+            } catch (IOException e) {
+                plugin.getLogger().info("Unable to check for updates: " + e.getMessage());
+            }
+        });
+
+
+    }
+}

src/main/resources/capacity.yml

@@ -1 +1,3 @@
-CHAINMAIL_HELMET: [ 9, 10, 11, 12, 13, 14, 15, 16, 17 ]
+CHAINMAIL_HELMET: [ 9, 10, 11, 12, 13, 14, 15, 16, 17 ]
+#MATERIAL->CUSTOM_MODEL_DATA
+DIAMOND_HELMET->1000: [ 9, 10, 11, 12, 13, 14, 15, 16, 17 ]

src/main/resources/config.yml

@@ -1,2 +1,10 @@
 forceUseLegacy: false
-forceUseMD5Colors: false
+forceUseMD5Colors: false
+forceUseFoliaPatches: false
+
+checkForUpdates: true
+
+confirmThrowNoDropItem: true
+
+#Can be SINGLE_PAGE or MULTI_PAGES
+personalStorageType: SINGLE_PAGE

src/main/resources/plugin.yml

@@ -5,6 +5,8 @@ api-version: '1.13'
 description: Set no drop status to your items
 author: itzRedTea
 authors: [itzRedTea]
+softdepend: [ItemsAdder]
+folia-supported: true
 
 permissions:
   nodropx.give:
@@ -12,5 +14,9 @@ permissions:
   nodropx.reload:
     description: "Allows reload the plugin"
   nodropx.gui:
-    escription: "Allows open no drop gui"
-    default: true
+    description: "Allows open no drop gui"
+    default: true
+  nodropx.giveStorage:
+    description: "Allows give to storage"
+  nodropx.applyhand:
+    description: "Allows apply no drop to item in main hand"

src/main/resources/text/legacy/messages.yml

@@ -5,19 +5,38 @@ give:
   fail: "&4[!] &cFail! Check item type for valid."
   success: "&2&l[!] &aGived &e%item%&a to &e%player%&a amount &e%amount%&a!"
 reload: "&aPlugin successfully reloaded at %time% ms"
+applyHand:
+  fail: "&4&l[!] &cFailed to apply no drop!"
+  success: "&2&l[!] &aSuccessfully applied no drop status to your item!"
+giveToStorage:
+  fail: "&4[!] &cFail! Check item type for valid."
+  success: "&2&l[!] &aGived &e%item%&a to &e%player%&a amount &e%amount%&a to storage!"
 
 noPerms: "&4&l[!] &cNo perms for this!"
 noConsole: "&4&l[!] &cOnly players can use it!"
 noExists: "&4&l[!] &cThis player doesnt exists!"
 
 gui:
-  title: "&lPersonal storage"
-  frame:
-    name: "&7"
-    material: GLASS_PANE
-  prev:
-    name: "&cPrevious"
-    material: ARROW
-  next:
-    name: "&cNext"
-    material: ARROW
+  confirm:
+    title: "&lConfirm drop"
+    yesButton:
+      name: "&aYES"
+      lore:
+        - "&7Confirm throw no drop item"
+      material: ARROW
+    noButton:
+      name: "&cNO"
+      lore:
+        - "&7Cancel throw no drop item"
+      material: ARROW
+  personalStorage:
+    title: "&lPersonal storage"
+    frame:
+      name: "&7"
+      material: GLASS_PANE
+    prev:
+      name: "&cPrevious"
+      material: ARROW
+    next:
+      name: "&cNext"
+      material: ARROW

src/main/resources/text/md5/cosmetics.yml

@@ -1,3 +1,4 @@
 #name: "No drop"
 lore:
-  - "&7[&a✔&7] &#68cf0cN&#6cd41fo &#6fd932d&#73dd46r&#77e259o&#7be76cp &#7eec7fi&#82f192t&#86f5a6e&#89fab9m&#8dffcc!!"
+  - "&7[&a✔&7] &#68cf0cN&#6cd41fo &#6fd932d&#73dd46r&#77e259o&#7be76cp &#7eec7fi&#82f192t&#86f5a6e&#89fab9m&#8dffcc!!"
+

src/main/resources/text/md5/messages.yml

@@ -5,19 +5,38 @@ give:
   fail: "&4[!] &cFail! Check item type for valid."
   success: "&2&l[!] &aGived &e%item%&a to &e%player%&a amount &e%amount%&a!"
 reload: "&aPlugin successfully reloaded at %time% ms"
+applyHand:
+  fail: "&4&l[!] &cFailed to apply no drop!"
+  success: "&2&l[!] &aSuccessfully applied no drop status to your item!"
+giveToStorage:
+  fail: "&4[!] &cFail! Check item type for valid."
+  success: "&2&l[!] &aGived &e%item%&a to &e%player%&a amount &e%amount%&a to storage!"
 
 noPerms: "&4&l[!] &cNo perms for this!"
 noConsole: "&4&l[!] &cOnly players can use it!"
 noExists: "&4&l[!] &cThis player doesnt exists!"
 
 gui:
-  title: "&lPersonal storage"
-  frame:
-    name: "&7"
-    material: GLASS_PANE
-  prev:
-    name: "&cPrevious"
-    material: ARROW
-  next:
-    name: "&cNext"
-    material: ARROW
+  confirm:
+    title: "&lConfirm drop"
+    yesButton:
+      name: "&aYES"
+      lore:
+        - "&7Confirm throw no drop item"
+      material: GREEN_WOOL
+    noButton:
+      name: "&cNO"
+      lore:
+        - "&7Cancel throw no drop item"
+      material: RED_WOOL
+  personalStorage:
+    title: "&lPersonal storage"
+    frame:
+      name: "&7"
+      material: GLASS_PANE
+    prev:
+      name: "&cPrevious"
+      material: ARROW
+    next:
+      name: "&cNext"
+      material: ARROW

src/main/resources/text/mm/cosmetics.yml

@@ -1,3 +1,3 @@
 #name: "No drop"
 lore:
-  - "<gray>[<green>✔<gray>] <gradient:#68CF0C:#8DFFCC>No drop item!"
+  - "<gray>[<green>✔<gray>] <gradient:#68CF0C:#8DFFCC>No drop item!"

src/main/resources/text/mm/messages.yml

@@ -5,20 +5,38 @@ give:
   fail: "<dark_red><bold>[!] <red>Fail! Check item type for valid."
   success: "<green><bold>[!] <reset><green>Gived <yellow>%item%<green> to <yellow>%player%<green> amount <yellow>%amount%<green>!"
 reload: "<green>Plugin successfully reloaded at %time% ms"
-
+applyHand:
+  fail: "<dark_red><bold>[!] <red>Failed to apply no drop!"
+  success: "<green><bold>[!] <reset><green>Successfully applied no drop status to your item!"
+giveToStorage:
+  fail: "<dark_red><bold>[!] <red>Fail! Check item type for valid."
+  success: "<green><bold>[!] <reset><green>Gived <yellow>%item%<green> to <yellow>%player%<green> amount <yellow>%amount%<green> to storage!"
 
 noPerms: "<dark_red><bold>[!] <red>No perms for this!"
 noConsole: "<dark_red><bold>[!] <red>Only players can use it!"
 noExists: "<dark_red><bold>[!] <red>This player doesnt exists!"
 
 gui:
-  title: "<bold>Personal storage"
-  frame:
-    name: "&7"
-    material: GLASS_PANE
-  prev:
-    name: "<red>Previous"
-    material: ARROW
-  next:
-    name: "<red>Next"
-    material: ARROW
+  confirm:
+    title: "<bold>Confirm throw"
+    yesButton:
+      name: "<green>YES"
+      lore:
+        - "<gray>Confirm throw no drop item"
+      material: GREEN_WOOL
+    noButton:
+      name: "<red>NO"
+      lore:
+        - "<gray>Cancel throw no drop item"
+      material: RED_WOOL
+  personalStorage:
+    title: "<bold>Personal storage"
+    frame:
+      name: "<gray>"
+      material: GLASS_PANE
+    prev:
+      name: "<red>Previous"
+      material: ARROW
+    next:
+      name: "<red>Next"
+      material: ARROW