Update plugin.yml

New cmd library, update nbt library, new feature - allnodrop

README.md

@@ -1,7 +1,7 @@
 # NoDropX
 Give no drop items!
 =======
-<img src="https://i.imgur.com/4KNCfzl.png"></img>
+<img src="https://i.imgur.com/PMxKZEP.png"></img>
 
 # NoDropX
 **Give no drop items!**
@@ -23,6 +23,7 @@ SpigotMC resource: https://www.spigotmc.org/resources/nodropx.111485/
 - Mods support (tested on Arclight 1.16.5)
 - ItemsAdder support
 - Folia support
+- Items thats protect all items in inventory from death
 
 
 This plugin uses <a href="https://github.com/iRedTea/CarcadeX">CarcadeX</a> library

build.gradle

@@ -2,10 +2,11 @@ plugins {
     id 'java'
     id("com.github.johnrengelman.shadow") version "7.0.0"
     id("xyz.jpenilla.run-paper") version "2.1.0"
+    id 'org.jetbrains.kotlin.jvm' version '1.9.23'
 }
 
 group = 'me.redtea'
-version = '1.0.3-SNAPSHOT'
+version = '1.0.4-HOTFIX'
 
 repositories {
     mavenCentral()
@@ -17,6 +18,10 @@ repositories {
         name = "sonatype"
         url = "https://oss.sonatype.org/content/groups/public/"
     }
+    maven {
+        name = "sonatype"
+        url = "https://s01.oss.sonatype.org/content/repositories/snapshots/"
+    }
     maven {
         name = "CodeMC"
         url = uri("https://repo.codemc.io/repository/maven-public/")
@@ -31,12 +36,14 @@ repositories {
 }
 
 dependencies {
+    runtimeOnly("org.jetbrains.kotlin:kotlin-reflect:1.9.23")
     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 "me.mattstudios.utils:matt-framework:1.4"
+    implementation "tech.carcadex:kotlinbukkitkit-commands:1.0.0.4b-SNAPSHOT"
+    implementation "de.tr7zw:item-nbt-api:2.12.3"
     implementation "net.kyori:adventure-api:4.14.0"
     implementation "net.kyori:adventure-platform-bukkit:4.3.0"
     implementation files("libs/MiniMessages.jar")
@@ -61,6 +68,12 @@ tasks.withType(JavaCompile).configureEach {
     }
 }
 
+compileKotlin {
+    kotlinOptions {
+        jvmTarget=1.8
+    }
+}
+
 processResources {
     def props = [version: version]
     inputs.properties props
@@ -74,7 +87,6 @@ processResources {
 shadowJar {
     relocate 'de.tr7zw.changeme.nbtapi', 'me.redtea.nodropx.libs.tr7zw.nbt'
     relocate 'de.tr7zw.annotations', 'me.redtea.nodropx.libs.tr7zw.annotations'
-    relocate 'me.mattstudios.mf', 'me.redtea.nodropx.libs.commands'
     relocate 'dev.triumphteam', 'me.redtea.nodropx.libs.gui'
     relocate 'org.checkerframework', 'me.redtea.nodropx.libs.message.oskarsmc.libs.checker'
     relocate 'org.intellij', 'me.redtea.nodropx.libs.intellij'
@@ -83,6 +95,6 @@ shadowJar {
 
 tasks {
     runServer {
-        minecraftVersion("1.16.5")
+        minecraftVersion("1.12.2")
     }
 }

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

@@ -1,7 +1,8 @@
 package me.redtea.nodropx;
 
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
 import lombok.Getter;
-import me.mattstudios.mf.base.CommandManager;
 import me.redtea.nodropx.api.facade.NoDropAPI;
 import me.redtea.nodropx.api.facade.impl.NoDropXFacade;
 import me.redtea.nodropx.command.NoDropCommand;
@@ -32,6 +33,8 @@ 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.allnodrop.AllNoDropService;
+import me.redtea.nodropx.service.allnodrop.impl.AllNoDropServiceImpl;
 import me.redtea.nodropx.service.capasity.CapacityService;
 import me.redtea.nodropx.service.capasity.impl.CapacityServiceImpl;
 import me.redtea.nodropx.service.cosmetic.CosmeticService;
@@ -56,13 +59,16 @@ import me.redtea.nodropx.util.FoliaSupportedUtils;
 import me.redtea.nodropx.util.UpdateChecker;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.ServicePriority;
 import org.bukkit.plugin.java.JavaPlugin;
+import tech.carcadex.kotlinbukkitkit.commands.manager.CommandManager;
 
 import java.io.File;
 import java.util.List;
+import java.util.Objects;
 import java.util.UUID;
 
 public final class NoDropX extends JavaPlugin {
@@ -105,12 +111,14 @@ public final class NoDropX extends JavaPlugin {
         noDropCosmeticService.add(textContext.getLoreStrategy());
         noDropCosmeticService.load(YamlConfiguration.loadConfiguration(textContext.getCosmetics()));
 
+        dropConfirmService = getConfig().getBoolean("confirmThrowNoDropItem") ? new DropConfirmServiceImpl() : new DropConfirmNull();
         NBTService nbtService = new Tr7zwNBTServiceImpl();
         noDropService = new NoDropServiceImpl(nbtService, noDropCosmeticService);
         NoDropItemFactory noDropItemFactory = new NoDropItemFactoryImpl(noDropService);
         EventService eventService = new EventServiceImpl(noDropService);
         capacityService = new CapacityServiceImpl(this);
-        RespawnService respawnService = new RespawnServiceImpl(noDropService, capacityService);
+        AllNoDropService allNoDropService = new AllNoDropServiceImpl(nbtService);
+        RespawnService respawnService = new RespawnServiceImpl(noDropService, allNoDropService, capacityService);
 
         //EXPERIMENTAL! Folia support!
         FoliaSupporter foliaSupporter = new FoliaSupporter();
@@ -123,14 +131,14 @@ public final class NoDropX extends JavaPlugin {
                 .build();
         itemStackService = initItemStackService();
 
-        dropConfirmService = getConfig().getBoolean("confirmThrowNoDropItem") ? new DropConfirmServiceImpl() : new DropConfirmNull();
 
         menuFacade = initMenus();
         StorageService storageService = new StorageServiceImpl(menuFacade, personalStorageRepo, noDropService);
 
 
 
-        NoDropAPI noDropAPI = new NoDropXFacade(noDropService, noDropItemFactory, storageService, capacityService, itemStackService);
+        NoDropAPI noDropAPI = new NoDropXFacade(noDropService, noDropItemFactory, storageService, capacityService,
+                itemStackService, allNoDropService);
         noDropAPIInstance = noDropAPI;
 
 
@@ -141,13 +149,26 @@ public final class NoDropX extends JavaPlugin {
         Bukkit.getServicesManager().register(NoDropAPI.class,
                 noDropAPI, this, ServicePriority.Normal);
 
-        CommandManager commandManager = new CommandManager(this);
-        commandManager.getMessageHandler().register("cmd.no.permission", sender -> messages.get("noPerms").send(sender));
-        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 -> itemStackService.allMaterials());
-        commandManager.register(new NoDropCommand(messages, noDropAPI, menuFacade, this, itemStackService));
+        CommandManager commandManager = CommandManager.get(this);
+        commandManager.message("#no-perm", sender -> {
+            messages.get("noPerms").send(sender);
+            return Unit.INSTANCE;
+        });
+        commandManager.message("#for-players-only", sender -> {
+            messages.get("noConsole").send(sender);
+            return Unit.INSTANCE;
+        });
+        commandManager.message("#no-such-player", sender -> {
+            messages.get("noExists").send(sender);
+            return Unit.INSTANCE;
+        });
+        commandManager.message("#no-such-player", sender -> {
+            messages.get("usage").send(sender);
+            return Unit.INSTANCE;
+        });
+        commandManager.tabComplete("#materials", input -> itemStackService.allMaterials());
+        commandManager.register(new NoDropCommand(messages, noDropAPI, menuFacade, this,
+                itemStackService, dropConfirmService, eventService, allNoDropService));
         bStatsInit();
         printCredits();
         checkUpdates();
@@ -155,14 +176,15 @@ public final class NoDropX extends JavaPlugin {
 
     private MenuFacade initMenus() {
         CachedMenu personalStorageCachedMenu;
-        if(getConfig().getString("personalStorageType").equalsIgnoreCase("SINGLE_PAGE")) {
+        if (Objects.requireNonNull(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);
+        } else
+            personalStorageCachedMenu = new MFPageGui(messages, personalStorageRepo, noDropService, itemStackService, this);
 
-        Menu confirmMenu = new DropConfirmMFGui(messages, dropConfirmService);
+        Menu confirmMenu = new DropConfirmMFGui(messages, dropConfirmService, this);
         return new MenuFacadeImpl(personalStorageCachedMenu, confirmMenu);
     }
 
@@ -178,15 +200,15 @@ public final class NoDropX extends JavaPlugin {
     }
 
     private void checkUpdates() {
-        if(!getConfig().getBoolean("checkForUpdates")) {
+        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.");
+                getLogger().info(ChatColor.GREEN + "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/");
+                getLogger().info(ChatColor.YELLOW + "There is a new update available: " + ChatColor.GOLD + version);
+                getLogger().info(ChatColor.YELLOW + "Download it from " + ChatColor.GOLD + "https://www.spigotmc.org/resources/nodropx.111485/");
             }
         });
     }
@@ -199,13 +221,17 @@ public final class NoDropX extends JavaPlugin {
 
 
     private void printCredits() {
-        Bukkit.getLogger().info(ChatColor.GREEN + "************************************************************");
-        Bukkit.getLogger().info(ChatColor.GREEN + "* " + ChatColor.YELLOW + "NoDropX version " + ChatColor.GOLD + getDescription().getVersion() + ChatColor.GRAY + " (uses CarcadeX v. 1.0.7)");
-        Bukkit.getLogger().info(ChatColor.GREEN + "* " + ChatColor.YELLOW + "By " + ChatColor.RED + "itzRedTea");
-        Bukkit.getLogger().info(ChatColor.GREEN + "* "+ ChatColor.YELLOW + "Detected bukkit version " + ChatColor.GOLD + Bukkit.getBukkitVersion());
-        Bukkit.getLogger().info(ChatColor.GREEN + "* "+ ChatColor.YELLOW + "support HEX colors " + (supportHEX ? ChatColor.DARK_GREEN + "YES" : ChatColor.DARK_RED + "NO"));
-        Bukkit.getLogger().info(ChatColor.GREEN + "* "+ ChatColor.YELLOW + "support Kyori as lore " + (supportKyoriLore ? ChatColor.DARK_GREEN + "YES" : ChatColor.DARK_RED + "NO"));
-        Bukkit.getLogger().info(ChatColor.GREEN + "************************************************************");
+        printCreditLine("&a************************************************************");
+        printCreditLine("&a* &2&lNoDrop&a&lX&e version &6" + getDescription().getVersion() + "&7 (uses KotlinBukkitKIT v. 1.0.4)");
+        printCreditLine("&a* &eBy &citzRedTea");
+        printCreditLine("&a* &eDetected bukkit version &6" + Bukkit.getBukkitVersion());
+        printCreditLine("&a* &esupport HEX colors " + (supportHEX ? "&2YES" : "&4NO"));
+        printCreditLine("&a* &esupport Kyori as lore " + (supportKyoriLore ? "&2YES" : "&4NO"));
+        printCreditLine("&a************************************************************");
+    }
+
+    private void printCreditLine(String s) {
+        Bukkit.getConsoleSender().sendMessage(ChatColor.translateAlternateColorCodes('&', s));
     }
 
     public void onReload() {

src/main/java/me/redtea/nodropx/api/event/PlayerChangeNoDropEvent.java

@@ -11,10 +11,10 @@ import org.jetbrains.annotations.NotNull;
 /**
  * This event is called when item changes no drop status
  */
-public class ChangeNoDropEvent extends PlayerEvent implements Cancellable {
+public class PlayerChangeNoDropEvent extends PlayerEvent implements Cancellable {
     private static final HandlerList handlers = new HandlerList();
 
-    @Getter
+
     private final boolean newValue;
 
     @Getter
@@ -23,7 +23,7 @@ public class ChangeNoDropEvent extends PlayerEvent implements Cancellable {
 
     private boolean isCancelled;
 
-    public ChangeNoDropEvent(@NotNull Player who, boolean newValue, @NotNull ItemStack item) {
+    public PlayerChangeNoDropEvent(@NotNull Player who, boolean newValue, @NotNull ItemStack item) {
         super(who);
         this.newValue = newValue;
         this.item = item;
@@ -48,4 +48,7 @@ public class ChangeNoDropEvent extends PlayerEvent implements Cancellable {
         return handlers;
     }
 
+    public boolean getNewValue() {
+        return newValue;
+    }
 }

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

@@ -144,4 +144,55 @@ public interface NoDropAPI {
     default @NotNull ItemStack getNoDrop(@NotNull String material) {
         return getNoDrop(material, 1);
     }
+
+    /**
+     * Set AllNoDrop
+     * @param item the item who's AllNoDrop property are changing
+     * @param isAllNoDrop will the item save all items in player's inventory from death?
+     * @author redtea
+     * @since 1.0.4
+     */
+    ItemStack setAllNoDrop(@NotNull ItemStack item, boolean isAllNoDrop);
+
+    /**
+     * Check if item is AllNoDrop
+     * @param item the item being checked
+     * @return true if the item save all items in player's inventory from death
+     * @author redtea
+     * @since 1.0.4
+     */
+    boolean isAllNoDrop(@NotNull ItemStack item);
+
+    /**
+     * Generate new nodropall item by material and amount
+     * @param material material of item
+     * @param amount count of item
+     * @return nodropall item
+     * @author redtea
+     * @since 1.0.4
+     */
+    default ItemStack getAllNoDrop(@NotNull Material material, int amount) {
+        val item = new ItemStack(material, amount);
+        setAllNoDrop(item, true);
+        return item;
+    }
+
+    /**
+     * Generate new nodropall item by material and amount
+     * @param material material of item
+     * @param amount count of item
+     * @return nodropall item
+     * @author redtea
+     * @since 1.0.4
+     */
+
+    /**
+     * @see NoDropAPI#getAllNoDrop(Material, int)
+     */
+     ItemStack getAllNoDrop(@NotNull String material, int amount);
+
+    /**
+     * @see NoDropAPI#getAllNoDrop(Material, int)
+     */
+    void giveAllNoDrop(HumanEntity entity, @NotNull String material, int amount);
 }

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

@@ -5,6 +5,7 @@ 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.allnodrop.AllNoDropService;
 import me.redtea.nodropx.service.capasity.CapacityService;
 import me.redtea.nodropx.service.material.ItemStackService;
 import me.redtea.nodropx.service.nodrop.NoDropService;
@@ -27,6 +28,7 @@ public class NoDropXFacade implements NoDropAPI {
     private final StorageService storageService;
     private final CapacityService capacityService;
     private final ItemStackService itemStackService;
+    private final AllNoDropService allNoDropService;
 
     @Override
     public ItemStack setNoDrop(@NotNull ItemStack item, boolean isNoDrop) {
@@ -99,4 +101,25 @@ public class NoDropXFacade implements NoDropAPI {
     public @NotNull ItemStack getNoDrop(@NotNull String material, int amount) {
         return setNoDrop(itemStackService.get(material, amount), true);
     }
+
+    @Override
+    public ItemStack setAllNoDrop(@NotNull ItemStack item, boolean isAllNoDrop) {
+        allNoDropService.setAllNoDrop(item, isAllNoDrop);
+        return item;
+    }
+
+    @Override
+    public boolean isAllNoDrop(@NotNull ItemStack item) {
+        return allNoDropService.isAllNoDrop(item);
+    }
+
+    @Override
+    public ItemStack getAllNoDrop(@NotNull String material, int amount) {
+        return setAllNoDrop(itemStackService.get(material, amount), true);
+    }
+
+    @Override
+    public void giveAllNoDrop(HumanEntity entity, @NotNull String material, int amount) {
+        entity.getInventory().addItem(getAllNoDrop(material, amount));
+    }
 }

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

@@ -2,18 +2,21 @@ 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.menu.facade.MenuFacade;
 import me.redtea.nodropx.libs.message.container.Messages;
+import me.redtea.nodropx.service.allnodrop.AllNoDropService;
+import me.redtea.nodropx.service.dropconfirm.DropConfirmService;
+import me.redtea.nodropx.service.event.EventService;
 import me.redtea.nodropx.service.material.ItemStackService;
 import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.Nullable;
+import tech.carcadex.kotlinbukkitkit.commands.reflection.annotations.*;
 
 import java.util.Date;
 
@@ -22,23 +25,26 @@ import java.util.Date;
  * <p>/nodrop - usage</p>
  * <p>/nodrop give [Player] [Material] [Amount (optional)]</p>
  */
-@Command("nodrop")
+@Command(name = "nodrop")
 @RequiredArgsConstructor
-public class NoDropCommand extends CommandBase {
+public class NoDropCommand {
     private final Messages messages;
     private final NoDropAPI noDropAPI;
     private final MenuFacade menuFacade;
     private final NoDropX plugin;
     private final ItemStackService itemStackService;
+    private final DropConfirmService confirmService;
+    private final EventService eventService;
+    private final AllNoDropService allNoDropService;
 
     @Default
     public void onDefault(final CommandSender sender) {
         messages.get("usage").send(sender);
     }
 
-    @SubCommand("give")
-    @Permission("nodropx.give")
-    @Completion({"#players", "#materials", "#range:1-64"})
+    @SubCommand(name = "give")
+    @Permission(perm = "nodropx.give")
+    @TabComplete(complete = {"#players", "#materials", "#range:1-64"})
     public void onGive(final CommandSender sender,
                        final Player player,
                        final String material,
@@ -56,17 +62,17 @@ public class NoDropCommand extends CommandBase {
 
     }
 
-    @SubCommand("reload")
-    @Permission("nodropx.reload")
+    @SubCommand(name = "reload")
+    @Permission(perm = "nodropx.reload")
     public void onReload(final CommandSender sender) {
         long time = new Date().getTime();
         plugin.onReload();
         messages.get("reload").replaceAll("%time%", String.valueOf(new Date().getTime() - time)).send(sender);
     }
 
-    @SubCommand("giveStorage")
-    @Permission("nodropx.giveStorage")
-    @Completion({"#players", "#materials", "#range:1-64"})
+    @SubCommand(name = "giveStorage")
+    @Permission(perm = "nodropx.giveStorage")
+    @TabComplete(complete = {"#players", "#materials", "#range:1-64"})
     public void onGiveStorage(final CommandSender sender,
                               final String playerName,
                               final String material,
@@ -90,20 +96,75 @@ public class NoDropCommand extends CommandBase {
 
     }
 
-    @SubCommand("applyHand")
-    @Permission("nodropx.applyhand")
+    @SubCommand(name = "ignoreConfirm")
+    @Permission(perm = "nodropx.ignoreConfirm")
+    public void onIgnoreConfirm(final CommandSender sender, @Optional Player target) {
+        if(target == null) {
+            if(!(sender instanceof Player)) {
+                sender.sendMessage("player only");
+                return;
+            } else {
+                confirmService.forceConfirm((Player) sender);
+            }
+        } else {
+            confirmService.forceConfirm(target);
+        }
+    }
+
+    @SubCommand(name = "ignoreConfirmTimed")
+    @Permission(perm = "nodropx.ignoreConfirm.timed")
+    public void onIgnoreConfirmTimed(final CommandSender sender, Integer sec, @Optional Player target) {
+        if(target == null) {
+            if(!(sender instanceof Player)) {
+                sender.sendMessage("player only");
+                return;
+            } else {
+                confirmService.forceConfirm((Player) sender);
+                try {
+                    Bukkit.getScheduler().runTaskLater(plugin,() -> confirmService.removeForceConfirm((Player) sender),20L*sec);
+                } catch (UnsupportedOperationException e) {
+                    sender.sendMessage(ChatColor.RED + "This operation didn't supports on your environment");
+                }
+            }
+        } else {
+            confirmService.forceConfirm(target);
+            try {
+                Bukkit.getScheduler().runTaskLater(plugin,() -> confirmService.removeForceConfirm(target),20L*sec);
+            } catch (UnsupportedOperationException e) {
+                sender.sendMessage(ChatColor.RED + "This operation didn't supports on your environment");
+            }
+        }
+    }
+
+    @SubCommand(name = "noIgnoreConfirm")
+    @Permission(perm = "nodropx.noIgnoreConfirm")
+    public void onNoIgnoreConfirm(final CommandSender sender, @Optional Player target) {
+        if(target == null) {
+            if(!(sender instanceof Player)) {
+                sender.sendMessage("player only");
+                return;
+            } else {
+                confirmService.removeForceConfirm((Player) sender);
+            }
+        } else {
+            confirmService.removeForceConfirm(target);
+        }
+    }
+    @SubCommand(name = "applyHand")
+    @Permission(perm = "nodropx.applyhand")
     public void onApplyHand(final Player sender) {
         try {
-            noDropAPI.setNoDrop(sender.getInventory().getItemInMainHand(), true);
+            val event = eventService.callPlayerChangeNoDropEvent(sender, sender.getInventory().getItemInMainHand(), true);
+            noDropAPI.setNoDrop(sender.getInventory().getItemInMainHand(), event.getNewValue());
             messages.get("applyHand.success").send(sender);
         } catch (Throwable e) {
             messages.get("applyHand.fail").send(sender);
         }
     }
 
-    @SubCommand("gui")
-    @Alias("storage")
-    @Permission("nodropx.gui")
+    @SubCommand(name = "gui")
+    @Aliases(aliases = "storage")
+    @Permission(perm = "nodropx.gui")
     public void onGui(final Player sender) {
         menuFacade.openPersonalStorage(sender);
     }
@@ -115,4 +176,23 @@ public class NoDropCommand extends CommandBase {
         }
         return null;
     }
+
+    @SubCommand(name = "giveallnodrop")
+    @Permission(perm = "nodropx.giveallnodrop")
+    @TabComplete(complete = {"#players", "#materials", "#range:1-64"})
+    public void onGiveAllNoDrop(final CommandSender sender,
+                       final Player player,
+                       final String material,
+                       @Optional final Integer amount) {
+        try {
+            noDropAPI.giveAllNoDrop(player, material, amount == null || amount == 0 ? 1 : amount);
+            messages.get("give.success")
+                    .replaceAll("%item%", material)
+                    .replaceAll("%player%", player.getName())
+                    .replaceAll("%amount%", amount == null ? "1" : amount.toString())
+                    .send(sender);
+        } catch (Throwable e) {
+            messages.get("give.fail").send(sender);
+        }
+    }
 }

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

@@ -25,6 +25,7 @@ public class FoliaSupporter {
 
     @SneakyThrows
     public void run(RespawnService respawnService, Plugin plugin) {
+        try {
             String version = ((JsonObject) new JsonParser().parse(new FileReader("version_history.json"))).get("currentVersion").getAsString();
             if(!version.toLowerCase().contains("folia") && !plugin.getConfig().getBoolean("forceUseFoliaPatches")) {
                 return;
@@ -34,6 +35,8 @@ public class FoliaSupporter {
             this.respawnService = respawnService;
             Bukkit.getPluginManager().registerEvents(new FoliaDeathListener(), plugin);
             plugin.getLogger().info("Patches for Folia successfully applied!");
+        } catch (Throwable ignored) {}
+
     }
 
 

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

@@ -3,6 +3,7 @@ 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 me.redtea.nodropx.service.event.EventService;
 import me.redtea.nodropx.service.nodrop.NoDropService;
 import me.redtea.nodropx.service.respawn.RespawnService;
@@ -14,7 +15,10 @@ import org.bukkit.event.player.PlayerDropItemEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.event.player.PlayerRespawnEvent;
 
+import java.util.HashSet;
 import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
 
 @RequiredArgsConstructor
 public class PlayerHandler implements Listener {

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

@@ -5,18 +5,26 @@ 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.Bukkit;
 import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
 
 public class DropConfirmMFGui implements Menu {
     private final Gui gui;
-    public DropConfirmMFGui(Messages messages, DropConfirmService dropConfirmService) {
+    private final Set<UUID> inMenu = new HashSet<>();
+    private final DropConfirmService dropConfirmService;
+    private final Plugin plugin;
+    public DropConfirmMFGui(Messages messages, DropConfirmService dropConfirmService, Plugin plugin) {
         gui = Gui.gui()
                 .rows(1)
                 .title(messages.get("gui.confirm.title").asComponent())
                 .disableAllInteractions()
                 .create();
+        this.plugin = plugin;
         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())
@@ -29,10 +37,28 @@ public class DropConfirmMFGui implements Menu {
                 .name(messages.get("gui.confirm.noButton.name").asComponent())
                 .lore(messages.get("gui.confirm.noButton.lore").asComponent())
                 .asGuiItem((event -> event.getWhoClicked().closeInventory())));
+        gui.setCloseGuiAction((e) -> {
+            inMenu.remove(e.getPlayer().getUniqueId());
+        });
+        this.dropConfirmService = dropConfirmService;
     }
 
     @Override
     public void open(Player player) {
+        if(inMenu.contains(player.getUniqueId())) {
+            dropConfirmService.forceConfirm(player);
+            player.closeInventory();
+            try {
+                Bukkit.getScheduler().runTaskLater(plugin,
+                        () -> dropConfirmService.removeForceConfirm(player),
+                        20*15L);
+            } catch (Throwable e) {
+                plugin.getLogger().severe("Can not start task. Maybe will bugs. Do you run on Folia?");
+                e.printStackTrace();
+            }
+            return;
+        }
+        inMenu.add(player.getUniqueId());
         gui.open(player);
     }
 }

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

@@ -5,6 +5,7 @@ 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 me.redtea.nodropx.util.MD5ColorUtils;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.Inventory;
@@ -25,7 +26,7 @@ public class SinglePageGui implements CachedMenu {
             player.openInventory(cache.get(player.getUniqueId()));
             return;
         }
-        Inventory gui = Bukkit.createInventory(null, 54, messages.get("gui.personalStorage.title").asComponent());
+        Inventory gui = Bukkit.createInventory(null, 54, MD5ColorUtils.translateHexColorCodes(messages.get("gui.personalStorage.title").asUnparsedString()));
         for(ItemStack item : personalStorageRepo.get(player.getUniqueId()).orElse(new ArrayList<>())) if(item != null) gui.addItem(item);
 
         cache.put(player.getUniqueId(), gui);

src/main/java/me/redtea/nodropx/service/allnodrop/AllNoDropService.java

@@ -0,0 +1,27 @@
+package me.redtea.nodropx.service.allnodrop;
+
+import org.bukkit.inventory.ItemStack;
+
+/**
+ * Service for checking all no drop items
+ * @since 1.0.4
+ * @author redtea
+ */
+public interface AllNoDropService {
+    /**
+     * Set no drop to item
+     * @param item the item who's no drop property are changing
+     * @param isAllNoDrop will the item can drop from inventory on death?
+     * @author redtea
+     * @since 1.0.4
+     */
+    void setAllNoDrop(ItemStack item, boolean isAllNoDrop);
+    /**
+     * Check if item is NoDropAll
+     * @param item the item being checked
+     * @return true if item is NoDropAll
+     * @author redtea
+     * @since 1.0.4
+     */
+    boolean isAllNoDrop(ItemStack item);
+}

src/main/java/me/redtea/nodropx/service/allnodrop/impl/AllNoDropServiceImpl.java

@@ -0,0 +1,22 @@
+package me.redtea.nodropx.service.allnodrop.impl;
+
+import lombok.RequiredArgsConstructor;
+import me.redtea.nodropx.service.allnodrop.AllNoDropService;
+import me.redtea.nodropx.service.nbt.NBTService;
+import org.bukkit.inventory.ItemStack;
+
+@RequiredArgsConstructor
+public class AllNoDropServiceImpl implements AllNoDropService {
+    private final NBTService nbtService;
+
+    @Override
+    public void setAllNoDrop(ItemStack item, boolean isAllNoDrop) {
+        nbtService.setBoolTag(item, "isAllNoDrop", isAllNoDrop);
+        nbtService.setBoolTag(item, "isNoDrop", isAllNoDrop);
+    }
+
+    @Override
+    public boolean isAllNoDrop(ItemStack item) {
+        return nbtService.getBoolTag(item, "isAllNoDrop");
+    }
+}

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

@@ -6,4 +6,7 @@ public interface DropConfirmService {
     boolean isConfirmed(Player player);
     void confirm(Player player);
     void resetConfirm(Player player);
+
+    void forceConfirm(Player player);
+    void removeForceConfirm(Player player);
 }

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

@@ -18,4 +18,14 @@ public class DropConfirmNull implements DropConfirmService {
     public void resetConfirm(Player player) {
 
     }
+
+    @Override
+    public void forceConfirm(Player player) {
+
+    }
+
+    @Override
+    public void removeForceConfirm(Player player) {
+
+    }
 }

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

@@ -9,8 +9,10 @@ import java.util.UUID;
 
 public class DropConfirmServiceImpl implements DropConfirmService {
     private Set<UUID> confirmed = new HashSet<>();
+    private Set<UUID> force = new HashSet<>();
     @Override
     public boolean isConfirmed(Player player) {
+        if(force.contains(player.getUniqueId()) || player.isDead()) return true;
         return confirmed.contains(player.getUniqueId());
     }
 
@@ -24,4 +26,14 @@ public class DropConfirmServiceImpl implements DropConfirmService {
         confirmed.remove(player.getUniqueId());
     }
 
+    @Override
+    public void forceConfirm(Player player) {
+        force.add(player.getUniqueId());
+    }
+
+    @Override
+    public void removeForceConfirm(Player player) {
+        force.remove(player.getUniqueId());
+    }
+
 }

src/main/java/me/redtea/nodropx/service/event/EventService.java

@@ -1,12 +1,16 @@
 package me.redtea.nodropx.service.event;
 
 import me.redtea.nodropx.api.event.NoDropItemThrownEvent;
+import me.redtea.nodropx.api.event.PlayerChangeNoDropEvent;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Cancellable;
 import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Optional;
 
 public interface EventService {
-    void callThrownEvent(Player who, ItemStack item, NoDropItemThrownEvent.Reason reason, Optional<Cancellable> rootEvent);
+    PlayerChangeNoDropEvent callPlayerChangeNoDropEvent(Player who, ItemStack item, boolean value);
+    @Nullable
+    NoDropItemThrownEvent callThrownEvent(Player who, ItemStack item, NoDropItemThrownEvent.Reason reason, Optional<Cancellable> rootEvent);
 }

src/main/java/me/redtea/nodropx/service/event/impl/EventServiceImpl.java

@@ -2,6 +2,7 @@ package me.redtea.nodropx.service.event.impl;
 
 import lombok.RequiredArgsConstructor;
 import me.redtea.nodropx.api.event.NoDropItemThrownEvent;
+import me.redtea.nodropx.api.event.PlayerChangeNoDropEvent;
 import me.redtea.nodropx.service.event.EventService;
 import me.redtea.nodropx.service.nodrop.NoDropService;
 import org.bukkit.Bukkit;
@@ -16,8 +17,15 @@ public class EventServiceImpl implements EventService {
     private final NoDropService noDropService;
 
     @Override
-    public void callThrownEvent(Player who, ItemStack item, NoDropItemThrownEvent.Reason reason, Optional<Cancellable> rootEvent) {
-        if(!noDropService.isNoDrop(item)) return;
+    public PlayerChangeNoDropEvent callPlayerChangeNoDropEvent(Player who, ItemStack item, boolean value) {
+        PlayerChangeNoDropEvent callingEvent = new PlayerChangeNoDropEvent(who, value, item);
+        Bukkit.getPluginManager().callEvent(callingEvent);
+        return callingEvent;
+    }
+
+    @Override
+    public NoDropItemThrownEvent callThrownEvent(Player who, ItemStack item, NoDropItemThrownEvent.Reason reason, Optional<Cancellable> rootEvent) {
+        if(!noDropService.isNoDrop(item)) return null;
         NoDropItemThrownEvent callingEvent = new NoDropItemThrownEvent(
                 who,
                 reason,
@@ -25,5 +33,6 @@ public class EventServiceImpl implements EventService {
         );
         Bukkit.getPluginManager().callEvent(callingEvent);
         rootEvent.ifPresent(cancellable -> cancellable.setCancelled(callingEvent.isCancelled()));
+        return callingEvent;
     }
 }

src/main/java/me/redtea/nodropx/service/nbt/NBTService.java

@@ -9,18 +9,20 @@ public interface NBTService {
     /**
      * Sets the NBT tag "isNoDrop", which indicates that the item is no drop
      * @param item editable item
-     * @param isNoDrop tag value
-     * @since 1.0.0
+     * @param tag nbt tag
+     * @param value tag value
+     * @since 1.0.4
      * @author redtea
      */
-    void setNoDropTag(ItemStack item, boolean isNoDrop);
+    void setBoolTag(ItemStack item, String tag, boolean value);
 
     /**
      * Gets the value of the "isNoDrop" tag, which indicates that the item is no drop
      * @param item checking item
+     * @param tag nbt tag
      * @return tag value
-     * @since 1.0.0
+     * @since 1.0.4
      * @author redtea
      */
-    boolean getNoDropTag(ItemStack item);
+    boolean getBoolTag(ItemStack item, String tag);
 }

src/main/java/me/redtea/nodropx/service/nbt/impl/Tr7zwNBTServiceImpl.java

@@ -6,17 +6,19 @@ import org.bukkit.Material;
 import org.bukkit.inventory.ItemStack;
 
 public class Tr7zwNBTServiceImpl implements NBTService {
+
+
     @Override
-    public void setNoDropTag(ItemStack item, boolean isNoDrop) {
+    public void setBoolTag(ItemStack item, String tag, boolean value) {
         NBTItem nbtItem = new NBTItem(item);
-        nbtItem.setBoolean("isNoDrop", true);
+        nbtItem.setBoolean(tag, value);
         nbtItem.applyNBT(item);
     }
 
     @Override
-    public boolean getNoDropTag(ItemStack item) {
+    public boolean getBoolTag(ItemStack item, String tag) {
         if(item == null || item.getType() == Material.AIR) return false;
         NBTItem nbtItem = new NBTItem(item);
-        return nbtItem.hasTag("isNoDrop") && nbtItem.getBoolean("isNoDrop");
+        return nbtItem.hasTag(tag) && nbtItem.getBoolean(tag);
     }
 }

src/main/java/me/redtea/nodropx/service/nodrop/impl/NoDropServiceImpl.java

@@ -13,13 +13,13 @@ public class NoDropServiceImpl implements NoDropService {
 
     @Override
     public void setNoDrop(ItemStack item, boolean isNoDrop) {
-        nbtService.setNoDropTag(item, isNoDrop);
+        nbtService.setBoolTag(item, "isNoDrop", true);
         cosmeticService.applyAll(item);
     }
 
     @Override
     public boolean isNoDrop(ItemStack item) {
         if(item == null) return false;
-        return nbtService.getNoDropTag(item);
+        return nbtService.getBoolTag(item, "isNoDrop");
     }
 }

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

@@ -6,10 +6,13 @@ 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.allnodrop.AllNoDropService;
 import me.redtea.nodropx.service.capasity.CapacityService;
+import me.redtea.nodropx.service.dropconfirm.DropConfirmService;
 import me.redtea.nodropx.service.nodrop.NoDropService;
 import me.redtea.nodropx.service.respawn.RespawnService;
 import org.bukkit.Bukkit;
+import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.event.entity.PlayerDeathEvent;
 import org.bukkit.inventory.ItemStack;
@@ -20,6 +23,7 @@ import java.util.stream.Collectors;
 @RequiredArgsConstructor
 public class RespawnServiceImpl implements RespawnService {
     private final NoDropService noDropService;
+    private final AllNoDropService allNoDropService;
     private final Map<String, Pair[]> toRespawn = new HashMap<>();
     private final CapacityService capacityService;
 
@@ -31,16 +35,17 @@ public class RespawnServiceImpl implements RespawnService {
             for(Pair pair : pairs) player.getInventory().setItem(pair.slot, pair.item);
             toRespawn.remove(player.getName());
         }
-        player.updateInventory();
     }
 
     @Override
     public void saveItemsBeforeDeath(PlayerDeathEvent event) {
         Player player = event.getEntity();
         Set<Integer> noDropSlots = new HashSet<>();
+        boolean isHasAllNoDropItem = event.getDrops().stream().anyMatch(allNoDropService::isAllNoDrop);
         for(int i = 0; i < player.getInventory().getSize(); ++i) {
             ItemStack item = player.getInventory().getItem(i);
-            if(!noDropService.isNoDrop(item)) continue;
+            if(!(noDropService.isNoDrop(item) || isHasAllNoDropItem) || item == null ||
+                item.getType() == Material.AIR) continue;
             NoDropItemDropOnDeathEvent callingEvent = new NoDropItemDropOnDeathEvent(
                     player,
                     item

src/main/resources/config.yml

@@ -4,7 +4,10 @@ forceUseFoliaPatches: false
 
 checkForUpdates: true
 
-confirmThrowNoDropItem: true
+# Not recommended on Forge servers!
+# Use it on your own risk
+confirmThrowNoDropItem: false
 
-#Can be SINGLE_PAGE or MULTI_PAGES
+#Single did not supports minimessages!
+#Can be SINGLE_PAGE or MULTI_PAGES (Use MULTI_PAGES on your own risk)
 personalStorageType: SINGLE_PAGE

src/main/resources/plugin.yml

@@ -7,10 +7,13 @@ author: itzRedTea
 authors: [itzRedTea]
 softdepend: [ItemsAdder]
 folia-supported: true
+website: https://github.com/iRedTea/NoDropX
 
 permissions:
   nodropx.give:
     description: "Allows give no drop items"
+  nodropx.giveallnodrop:
+    description: "Allows give allnodrop items"
   nodropx.reload:
     description: "Allows reload the plugin"
   nodropx.gui:

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

@@ -1,6 +1,6 @@
 usage:
   - "&7[ &aUsage of command &e/nodrop &7]"
-  - "&7| &a/give [player] [item] (amount) &e- give no drop item"
+  - "&7| &a/nodrop give [player] [item] (amount) &e- give no drop item"
 give:
   fail: "&4[!] &cFail! Check item type for valid."
   success: "&2&l[!] &aGived &e%item%&a to &e%player%&a amount &e%amount%&a!"

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

@@ -1,6 +1,6 @@
 usage:
   - "&7[ &aUsage of command &e/nodrop &7]"
-  - "&7| &a/give [player] [item] (amount) &e- give no drop item"
+  - "&7| &a/nodrop give [player] [item] (amount) &e- give no drop item"
 give:
   fail: "&4[!] &cFail! Check item type for valid."
   success: "&2&l[!] &aGived &e%item%&a to &e%player%&a amount &e%amount%&a!"

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

@@ -1,6 +1,6 @@
 usage:
   - "<gray>[ <green>Usage of command <yellow>/nodrop <gray>]"
-  - "<gray>| <green>/give [player] [item] (amount) <yellow>- give no drop item"
+  - "<gray>| <green>/nodrop give [player] [item] (amount) <yellow>- give no drop item"
 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>!"