Add RepairCommand

plugin/src/main/java/com/alttd/essentia/EssentiaPlugin.java

@@ -58,7 +58,7 @@ public class EssentiaPlugin extends JavaPlugin implements EssentiaAPI {
     }
 
     void loadCommands() {
-        Reflections reflections = new Reflections("com.alttd.essentia.commands");
+        Reflections reflections = new Reflections("com.alttd.essentia.commands.list");
         Set<Class<?>> subTypes = reflections.get(Scanners.SubTypes.of(EssentiaCommand.class).asClass());
 
         LifecycleEventManager<Plugin> manager = this.getLifecycleManager();

plugin/src/main/java/com/alttd/essentia/commands/EssentiaCommand.java

@@ -9,6 +9,8 @@ import java.util.List;
 // TODO -- add optional -s -silent parameters to commands?
 public interface EssentiaCommand {
 
+    String commandName();
+
     @NotNull LiteralCommandNode<CommandSourceStack> command();
 
     default String description() {
@@ -19,4 +21,20 @@ public interface EssentiaCommand {
         return Collections.emptyList();
     }
 
+    default String baseCommandPermission() {
+        return "essentia.command.player." + commandName();
+    }
+
+    default String baseOtherCommandPermission() {
+        return "essentia.command.player." + commandName() + "other";
+    }
+
+    default String adminCommandPermission() {
+        return "essentia.command.admin." + commandName();
+    }
+
+    default String adminOtherCommandPermission() {
+        return "essentia.command.admin." + commandName() + "other";
+    }
+
 }

plugin/src/main/java/com/alttd/essentia/commands/admin/BurnCommand.java

@@ -16,14 +16,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class BurnCommand implements EssentiaCommand {
 
-    static String commandName = "burn";
+    @Override
+    public String commandName() {
+        return "burn";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
                         )
                         .executes((source) -> {
                             if (source.getSource().getSender() instanceof Player player)
@@ -33,7 +36,7 @@ public class BurnCommand implements EssentiaCommand {
                         })
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/ClearInventoryCommand.java

@@ -16,14 +16,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class ClearInventoryCommand implements EssentiaCommand {
 
-    static String commandName = "clearinventory";
+    @Override
+    public String commandName() {
+        return "clearinventory";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .executes((source) -> {
@@ -34,7 +37,7 @@ public class ClearInventoryCommand implements EssentiaCommand {
                         })
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/CuffCommand.java

@@ -19,18 +19,21 @@ import org.jetbrains.annotations.NotNull;
 
 public class CuffCommand implements EssentiaCommand {
 
-    static String commandName = "cuff";
+    @Override
+    public String commandName() {
+        return "cuff";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
                         )
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/EnchantCommand.java

@@ -20,14 +20,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class EnchantCommand implements EssentiaCommand {
 
-    static String commandName = "enchant";
+    @Override
+    public String commandName() {
+        return "enchant";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
                         )
                         .then(
                                 Commands.argument("enchantment", new EnchantmentArgument())
@@ -51,7 +54,7 @@ public class EnchantCommand implements EssentiaCommand {
                                                         })
                                                         .then(
                                                                 Commands.argument("player", ArgumentTypes.player())
-                                                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                                                         .executes((source) -> {
                                                                             CommandSourceStack sourceStack = source.getSource();
                                                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/EssentiaAdminCommand.java

@@ -10,11 +10,16 @@ import org.jetbrains.annotations.NotNull;
 
 public class EssentiaAdminCommand implements EssentiaCommand {
 
+    @Override
+    public String commandName() {
+        return "essentiareload";
+    }
+
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal("essentia")
+                Commands.literal(commandName())
-                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin.reload"))
+                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()))
                         .executes((commandContext -> 1))
                         .then(
                                 Commands.literal("reload")

plugin/src/main/java/com/alttd/essentia/commands/admin/FeedCommand.java

@@ -16,14 +16,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class FeedCommand implements EssentiaCommand {
 
-    static String commandName = "feed";
+    @Override
+    public String commandName() {
+        return "feed";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .executes((source) -> {
@@ -34,7 +37,7 @@ public class FeedCommand implements EssentiaCommand {
                         })
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/FlyCommand.java

@@ -20,14 +20,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class FlyCommand implements EssentiaCommand {
 
-    static String commandName = "fly";
+    @Override
+    public String commandName() {
+        return "fly";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .executes((source) -> {
@@ -38,7 +41,7 @@ public class FlyCommand implements EssentiaCommand {
                         })
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/FlySpeedCommand.java

@@ -18,14 +18,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class FlySpeedCommand implements EssentiaCommand {
 
-    static String commandName = "flyspeed";
+    @Override
+    public String commandName() {
+        return "flyspeed";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
                         ).then(
                                 Commands.argument("speed", FloatArgumentType.floatArg(-1, 1))
                                         .executes((source) -> {
@@ -39,7 +42,7 @@ public class FlySpeedCommand implements EssentiaCommand {
                                         })
                                         .then(
                                             Commands.argument("player", ArgumentTypes.player())
-                                                    .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                                    .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                                     .executes((source) -> {
                                                         CommandSourceStack sourceStack = source.getSource();
                                                         Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/GameModeCommand.java

@@ -1,7 +1,6 @@
 package com.alttd.essentia.commands.admin;
 
 import com.alttd.essentia.commands.EssentiaCommand;
-import com.alttd.essentia.commands.argumement.GameModeArgument;
 import com.alttd.essentia.configuration.Config;
 import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.tree.LiteralCommandNode;
@@ -18,17 +17,20 @@ import org.jetbrains.annotations.NotNull;
 
 public class GameModeCommand implements EssentiaCommand {
 
-    static String commandName = "gamemode";
+    @Override
+    public String commandName() {
+        return "gamemode";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
                         )
                         .then(
-                                Commands.argument("gamemode", new GameModeArgument())
+                                Commands.argument("gamemode", ArgumentTypes.gameMode())
                                         .executes((source) -> {
                                             if (!(source.getSource().getSender() instanceof Player player))
                                                 return 1;
@@ -39,7 +41,7 @@ public class GameModeCommand implements EssentiaCommand {
                                         })
                                         .then(
                                                 Commands.argument("player", ArgumentTypes.player())
-                                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                                         .executes((source) -> {
                                                             CommandSourceStack sourceStack = source.getSource();
                                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/GodCommand.java

@@ -20,14 +20,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class GodCommand implements EssentiaCommand {
 
-    static String commandName = "god";
+    @Override
+    public String commandName() {
+        return "god";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .executes((source) -> {
@@ -38,7 +41,7 @@ public class GodCommand implements EssentiaCommand {
                         })
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/HealCommand.java

@@ -14,17 +14,19 @@ import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 
-public class HealCommand
+public class HealCommand implements EssentiaCommand {
-        implements EssentiaCommand {
 
-    static String commandName = "heal";
+    @Override
+    public String commandName() {
+        return "heal";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .executes((source) -> {
@@ -35,7 +37,7 @@ public class HealCommand
                         })
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/InfoCommand.java

@@ -15,14 +15,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class InfoCommand implements EssentiaCommand {
 
-    static String commandName = "info";
+    @Override
+    public String commandName() {
+        return "info";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
                         )
                         .executes((source) -> {
                             if (source.getSource().getSender() instanceof Player player)
@@ -32,7 +35,7 @@ public class InfoCommand implements EssentiaCommand {
                         })
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/PlayerTimeCommand.java

@@ -0,0 +1,97 @@
+package com.alttd.essentia.commands.admin;
+
+import com.alttd.essentia.commands.EssentiaCommand;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.tree.LiteralCommandNode;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.command.brigadier.Commands;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+// TODO -- output messages
+public class PlayerTimeCommand implements EssentiaCommand {
+
+    @Override
+    public String commandName() {
+        return "playertime";
+    }
+
+    @Override
+    public @NotNull LiteralCommandNode<CommandSourceStack> command() {
+        final LiteralArgumentBuilder<CommandSourceStack> builder =
+                Commands.literal(commandName())
+                        .requires(
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
+                                    commandSourceStack.getSender() instanceof Player
+                        )
+                        .then(
+                                Commands.literal("freeze")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                setTime(player, player.getPlayerTime());
+
+                                            return 1;
+                                        })
+                        )
+                        .then(
+                                Commands.literal("unfreeze")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                reset(player);
+
+                                            return 1;
+                                        })
+                        )
+                        .then(
+                                Commands.literal("day")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                setTime(player, 1000);
+
+                                            return 1;
+                                        })
+                        )
+                        .then(
+                                Commands.literal("noon")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                setTime(player, 6000);
+
+                                            return 1;
+                                        })
+                        )
+                        .then(
+                                Commands.literal("night")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                setTime(player, 13000);
+
+                                            return 1;
+                                        })
+                        )
+                        .then(
+                                Commands.literal("midnight")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                setTime(player, 18000);
+
+                                            return 1;
+                                        })
+                        );
+        return builder.build();
+    }
+
+    void reset(Player player) {
+        player.resetPlayerTime();
+    }
+
+    void setTime(Player player, long time) {
+        player.setPlayerTime(time, false);
+    }
+
+    public List<String> aliases() {
+        return List.of("ptime");
+    }
+}

plugin/src/main/java/com/alttd/essentia/commands/admin/PlayerWeatherCommand.java

@@ -0,0 +1,80 @@
+package com.alttd.essentia.commands.admin;
+
+import com.alttd.essentia.commands.EssentiaCommand;
+import com.alttd.essentia.commands.argumement.WeatherArgument;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.tree.LiteralCommandNode;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.command.brigadier.Commands;
+import io.papermc.paper.command.brigadier.argument.ArgumentTypes;
+import io.papermc.paper.command.brigadier.argument.resolvers.selector.PlayerSelectorArgumentResolver;
+import org.bukkit.WeatherType;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+// TODO -- output messages
+public class PlayerWeatherCommand implements EssentiaCommand {
+
+    @Override
+    public String commandName() {
+        return "playerweather";
+    }
+
+    @Override
+    public @NotNull LiteralCommandNode<CommandSourceStack> command() {
+        final LiteralArgumentBuilder<CommandSourceStack> builder =
+                Commands.literal(commandName())
+                        .requires(
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
+                                        commandSourceStack.getSender() instanceof Player
+                        )
+                        .then(
+                                Commands.literal("reset")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                resetWeather(player);
+
+                                            return 1;
+                                        })
+                        )
+                        .then(
+                                Commands.argument("weather", new WeatherArgument())
+                                        .executes(commandContext -> {
+                                            if (!(commandContext.getSource().getSender() instanceof Player player))
+                                                return 1;
+
+                                            WeatherType weatherType = commandContext.getArgument("weather", WeatherType.class);
+                                            execute(commandContext.getSource().getSender(), player, weatherType);
+                                            return 1;
+                                        })
+                                        .then(
+                                                Commands.argument("player", ArgumentTypes.player())
+                                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
+                                                        .executes(commandContext -> {
+                                                            CommandSourceStack sourceStack = commandContext.getSource();
+                                                            Player target = commandContext.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();
+                                                            WeatherType weatherType = commandContext.getArgument("weather", WeatherType.class);
+                                                            execute(commandContext.getSource().getSender(), target, weatherType);
+                                                            return 1;
+                                                        })
+                                        )
+                        );
+        return builder.build();
+    }
+
+    public void execute(CommandSender sender, Player target, WeatherType weatherType) {
+        target.setPlayerWeather(weatherType);
+    }
+
+    void resetWeather(Player player) {
+        player.resetPlayerWeather();
+    }
+
+    public List<String> aliases() {
+        return List.of("pweather");
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/commands/admin/RepairCommand.java

@@ -0,0 +1,79 @@
+package com.alttd.essentia.commands.admin;
+
+import com.alttd.essentia.commands.EssentiaCommand;
+import com.alttd.essentia.commands.argumement.EquipmentArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.tree.LiteralCommandNode;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.command.brigadier.Commands;
+import io.papermc.paper.command.brigadier.argument.ArgumentTypes;
+import io.papermc.paper.command.brigadier.argument.resolvers.selector.PlayerSelectorArgumentResolver;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.Damageable;
+import org.jetbrains.annotations.NotNull;
+
+public class RepairCommand implements EssentiaCommand {
+
+    @Override
+    public String commandName() {
+        return "repair";
+    }
+
+    @Override
+    public @NotNull LiteralCommandNode<CommandSourceStack> command() {
+        final LiteralArgumentBuilder<CommandSourceStack> builder =
+                Commands.literal(commandName())
+                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()))
+//                        .executes((source) -> {
+//                            if (source.getSource().getSender() instanceof Player player)
+//                                execute(player, player);
+//
+//                            return 1;
+//                        })
+                        .then(Commands.argument("equipmentslot", new EquipmentArgumentType())
+                            .executes((source) -> {
+                                if (!(source.getSource().getSender() instanceof Player player))
+                                    return 1;
+
+                                EquipmentSlot equipmentSlot = source.getArgument("equipmentslot", EquipmentSlot.class);
+                                execute(source.getSource().getSender(), player, equipmentSlot);
+                                return 1;
+                            })
+                            .then(
+                                    Commands.argument("player", ArgumentTypes.player())
+                                            .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
+                                            .executes((source) -> {
+                                                CommandSourceStack sourceStack = source.getSource();
+                                                Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();
+                                                EquipmentSlot equipmentSlot = source.getArgument("equipmentslot", EquipmentSlot.class);
+                                                execute(source.getSource().getSender(), target, equipmentSlot);
+                                                return 1;
+                                            })
+                            )
+                        );
+        return builder.build();
+    }
+
+    // TODO - placeholders and messages from config
+    public void execute(CommandSender sender, Player target, EquipmentSlot equipmentSlot) {
+        TagResolver placeholders = TagResolver.resolver(
+                Placeholder.component("requester", sender.name()),
+                Placeholder.component("target", target.displayName())
+        );
+
+        ItemStack itemStack = target.getInventory().getItem(equipmentSlot);
+        if (!(itemStack.getItemMeta() instanceof Damageable damageable))
+            return; // send message can not repair this item
+
+        damageable.setDamage(0);
+        sender.sendRichMessage(target == sender ? "You have repaired your <item>." : "<sender> has repaired your <item>.", placeholders);
+        if (target != sender)
+            target.sendRichMessage("You repaired <target>'s <item>.", placeholders);
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/commands/admin/SetSpawnCommand.java

@@ -0,0 +1,48 @@
+package com.alttd.essentia.commands.admin;
+
+import com.alttd.essentia.commands.EssentiaCommand;
+import com.alttd.essentia.configuration.Config;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.tree.LiteralCommandNode;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.command.brigadier.Commands;
+import org.bukkit.World;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public class SetSpawnCommand implements EssentiaCommand {
+
+    @Override
+    public String commandName() {
+        return "setspawn";
+    }
+
+    @Override
+    public @NotNull LiteralCommandNode<CommandSourceStack> command() {
+        final LiteralArgumentBuilder<CommandSourceStack> builder =
+                Commands.literal(commandName())
+                        .requires(
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
+                                        commandSourceStack.getSender() instanceof Player
+                        )
+                        .executes((source) -> {
+                            if (source.getSource().getSender() instanceof Player player)
+                                execute(player, player);
+
+                            return 1;
+                        });
+        return builder.build();
+    }
+
+    public void execute(CommandSender sender, Player target) {
+        // Todo - output messages
+        World world = target.getWorld();
+        world.setSpawnLocation(target.getLocation());
+        // TODO -- method in config to update & save
+        Config.config.set("spawn-world", world.getName());
+        Config.SPAWN_WORLD = world.getName();
+        Config.saveConfig();
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/commands/admin/SmiteCommand.java

@@ -18,14 +18,17 @@ import java.util.List;
 
 public class SmiteCommand implements EssentiaCommand {
 
-    static String commandName = "smite";
+    @Override
+    public String commandName() {
+        return "smite";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
                         )
                         .executes((source) -> {
                             if (source.getSource().getSender() instanceof Player player)
@@ -35,7 +38,7 @@ public class SmiteCommand implements EssentiaCommand {
                         })
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/TeleportCommand.java

@@ -14,19 +14,22 @@ import java.util.List;
 
 public class TeleportCommand implements EssentiaCommand {
 
-    static String commandName = "teleport";
+    @Override
+    public String commandName() {
+        return "teleport";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/TeleportHereCommand.java

@@ -14,19 +14,22 @@ import java.util.List;
 
 public class TeleportHereCommand implements EssentiaCommand {
 
-    static String commandName = "teleporthere";
+    @Override
+    public String commandName() {
+        return "teleporthere";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/TeleportPositionCommand.java

@@ -16,14 +16,17 @@ import java.util.List;
 
 public class TeleportPositionCommand implements EssentiaCommand {
 
-    static String commandName = "teleportposition";
+    @Override
+    public String commandName() {
+        return "teleportposition";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .then(
@@ -39,7 +42,7 @@ public class TeleportPositionCommand implements EssentiaCommand {
                                         })
                                         .then(
                                                 Commands.argument("player", ArgumentTypes.player())
-                                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                                         .executes((source) -> {
                                                             if (!(source.getSource().getSender() instanceof Player player))
                                                                 return 1;

plugin/src/main/java/com/alttd/essentia/commands/admin/TimeCommand.java

@@ -0,0 +1,93 @@
+package com.alttd.essentia.commands.admin;
+
+import com.alttd.essentia.commands.EssentiaCommand;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.tree.LiteralCommandNode;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.command.brigadier.Commands;
+import org.bukkit.GameRule;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+// TODO -- output messages
+public class TimeCommand implements EssentiaCommand {
+
+    @Override
+    public String commandName() {
+        return "time";
+    }
+
+    @Override
+    public @NotNull LiteralCommandNode<CommandSourceStack> command() {
+        final LiteralArgumentBuilder<CommandSourceStack> builder =
+                Commands.literal(commandName())
+                        .requires(
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
+                                    commandSourceStack.getSender() instanceof Player
+                        )
+                        .then(
+                                Commands.literal("freeze")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                freeze(player, true);
+
+                                            return 1;
+                                        })
+                        )
+                        .then(
+                                Commands.literal("unfreeze")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                freeze(player, false);
+
+                                            return 1;
+                                        })
+                        )
+                        .then(
+                                Commands.literal("day")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                setTime(player, 1000);
+
+                                            return 1;
+                                        })
+                        )
+                        .then(
+                                Commands.literal("noon")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                setTime(player, 6000);
+
+                                            return 1;
+                                        })
+                        )
+                        .then(
+                                Commands.literal("night")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                setTime(player, 13000);
+
+                                            return 1;
+                                        })
+                        )
+                        .then(
+                                Commands.literal("midnight")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                setTime(player, 18000);
+
+                                            return 1;
+                                        })
+                        );
+        return builder.build();
+    }
+
+    void freeze(Player player, boolean value) {
+        player.getWorld().setGameRule(GameRule.DO_DAYLIGHT_CYCLE, value);
+    }
+
+    void setTime(Player player, int time) {
+        player.getWorld().setTime(time);
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/commands/admin/UnCuffCommand.java

@@ -19,18 +19,21 @@ import org.jetbrains.annotations.NotNull;
 
 public class UnCuffCommand implements EssentiaCommand {
 
-    static String commandName = "uncuff";
+    @Override
+    public String commandName() {
+        return "uncuff";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
                         )
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/WalkSpeedCommand.java

@@ -18,14 +18,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class WalkSpeedCommand implements EssentiaCommand {
 
-    static String commandName = "walkspeed";
+    @Override
+    public String commandName() {
+        return "walkspeed";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
                         ).then(
                                 Commands.argument("speed", FloatArgumentType.floatArg(-1, 1))
                                         .executes((source) -> {
@@ -39,7 +42,7 @@ public class WalkSpeedCommand implements EssentiaCommand {
                                         })
                                         .then(
                                             Commands.argument("player", ArgumentTypes.player())
-                                                    .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                                    .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                                     .executes((source) -> {
                                                         CommandSourceStack sourceStack = source.getSource();
                                                         Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/admin/WeatherCommand.java

@@ -0,0 +1,103 @@
+package com.alttd.essentia.commands.admin;
+
+import com.alttd.essentia.commands.EssentiaCommand;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.tree.LiteralCommandNode;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.command.brigadier.Commands;
+import io.papermc.paper.command.brigadier.argument.ArgumentTypes;
+import io.papermc.paper.command.brigadier.argument.resolvers.selector.PlayerSelectorArgumentResolver;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import org.bukkit.World;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Random;
+
+// TODO -- output messages
+public class WeatherCommand implements EssentiaCommand {
+
+    @Override
+    public String commandName() {
+        return "weather";
+    }
+
+    @Override
+    public @NotNull LiteralCommandNode<CommandSourceStack> command() {
+        final LiteralArgumentBuilder<CommandSourceStack> builder =
+                Commands.literal(commandName())
+                        .requires(
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()) &&
+                                    commandSourceStack.getSender() instanceof Player
+                        )
+                        .then(
+                                Commands.literal("clear")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                clearWeather(player, -1);
+
+                                            return 1;
+                                        })
+                                        .then(
+                                                Commands.argument("duration", ArgumentTypes.time())
+                                                        .executes(commandContext -> {
+                                                            int duration = commandContext.getArgument("duration", Integer.class);
+                                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                                clearWeather(player, duration);
+
+                                                            return 1;
+                                                        })
+                                        )
+                        )
+                        .then(
+                                Commands.literal("rain")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                setRain(player, -1, false);
+
+                                            return 1;
+                                        })
+                                        .then(
+                                                Commands.argument("duration", ArgumentTypes.time())
+                                                        .executes(commandContext -> {
+                                                            int duration = commandContext.getArgument("duration", Integer.class);
+                                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                                setRain(player, duration, false);
+                                                            return 1;
+                                                        })
+                                        )
+                        )
+                        .then(
+                                Commands.literal("thunder")
+                                        .executes(commandContext -> {
+                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                setRain(player, -1, true);
+
+                                            return 1;
+                                        })
+                                        .then(
+                                                Commands.argument("duration", ArgumentTypes.time())
+                                                        .executes(commandContext -> {
+                                                            int duration = commandContext.getArgument("duration", Integer.class);
+                                                            if (commandContext.getSource().getSender() instanceof Player player)
+                                                                setRain(player, duration, true);
+                                                            return 1;
+                                                        })
+                                        )
+                        );
+        return builder.build();
+    }
+
+    public void clearWeather(Player player, int duration) {
+        player.getWorld().setClearWeatherDuration(duration == -1 ? new Random().nextInt() : duration);
+    }
+
+    public void setRain(Player player, int duration, boolean thunder) {
+        player.getWorld().setStorm(thunder);
+        player.getWorld().setWeatherDuration(duration == -1 ? new Random().nextInt() : duration);
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/commands/admin/WorkBenchCommand.java

@@ -17,14 +17,17 @@ import java.util.List;
 
 public class WorkBenchCommand implements EssentiaCommand {
 
-    static String commandName = "workbench";
+    @Override
+    public String commandName() {
+        return "workbench";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
                         )
                         .executes((source) -> {
                             if (source.getSource().getSender() instanceof Player player)
@@ -34,7 +37,7 @@ public class WorkBenchCommand implements EssentiaCommand {
                         })
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.admin." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/argumement/EnchantmentArgument.java

@@ -27,7 +27,7 @@ public class EnchantmentArgument implements CustomArgumentType.Converted<Enchant
         try {
             return Enchantment.getByKey(NamespacedKey.minecraft(nativeType));
         } catch (Exception e) {
-            Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid gamemode %s!".formatted(nativeType), NamedTextColor.RED));
+            Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid enchantment %s!".formatted(nativeType), NamedTextColor.RED));
 
             throw new CommandSyntaxException(new SimpleCommandExceptionType(message), message);
         }

plugin/src/main/java/com/alttd/essentia/commands/argumement/EquipmentArgumentType.java

@@ -0,0 +1,49 @@
+package com.alttd.essentia.commands.argumement;
+
+import com.mojang.brigadier.Message;
+import com.mojang.brigadier.arguments.ArgumentType;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import io.papermc.paper.command.brigadier.MessageComponentSerializer;
+import io.papermc.paper.command.brigadier.argument.CustomArgumentType;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.inventory.EquipmentSlot;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.CompletableFuture;
+
+public class EquipmentArgumentType implements CustomArgumentType.Converted<EquipmentSlot, String> {
+
+    @Override
+    public @NotNull EquipmentSlot convert(String nativeType) throws CommandSyntaxException {
+        try {
+            return EquipmentSlot.valueOf(nativeType.toUpperCase());
+        } catch (Exception e) {
+            Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid EquipmentSlot %s!".formatted(nativeType), NamedTextColor.RED));
+
+            throw new CommandSyntaxException(new SimpleCommandExceptionType(message), message);
+        }
+    }
+
+    @Override
+    public @NotNull ArgumentType<String> getNativeType() {
+        return StringArgumentType.word();
+    }
+
+    @Override
+    public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
+        for (EquipmentSlot equipmentSlot : EquipmentSlot.values()) {
+            builder.suggest(equipmentSlot.name().toLowerCase());
+        }
+
+        return CompletableFuture.completedFuture(
+                builder.build()
+        );
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/commands/argumement/WeatherArgument.java

@@ -12,19 +12,19 @@ import io.papermc.paper.command.brigadier.MessageComponentSerializer;
 import io.papermc.paper.command.brigadier.argument.CustomArgumentType;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
-import org.bukkit.GameMode;
+import org.bukkit.WeatherType;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.concurrent.CompletableFuture;
 
-public class GameModeArgument implements CustomArgumentType.Converted<GameMode, String> {
+public class WeatherArgument implements CustomArgumentType.Converted<WeatherType, String> {
 
     @Override
-    public @NotNull GameMode convert(String nativeType) throws CommandSyntaxException {
+    public @NotNull WeatherType convert(String nativeType) throws CommandSyntaxException {
         try {
-            return GameMode.valueOf(nativeType.toUpperCase());
+            return WeatherType.valueOf(nativeType.toUpperCase());
         } catch (Exception e) {
-            Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid gamemode %s!".formatted(nativeType), NamedTextColor.RED));
+            Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid WeatherType %s!".formatted(nativeType), NamedTextColor.RED));
 
             throw new CommandSyntaxException(new SimpleCommandExceptionType(message), message);
         }
@@ -37,8 +37,8 @@ public class GameModeArgument implements CustomArgumentType.Converted<GameMode,
 
     @Override
     public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
-        for (GameMode gameMode : GameMode.values()) {
+        for (WeatherType weatherType : WeatherType.values()) {
-            builder.suggest(gameMode.name().toLowerCase());
+            builder.suggest(weatherType.name().toLowerCase());
         }
 
         return CompletableFuture.completedFuture(

plugin/src/main/java/com/alttd/essentia/commands/player/BackCommand.java

@@ -18,14 +18,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class BackCommand implements EssentiaCommand {
 
-    static String commandName = "back";
+    @Override
+    public String commandName() {
+        return "back";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .executes((source) -> {

plugin/src/main/java/com/alttd/essentia/commands/player/DeathBackCommand.java

@@ -20,14 +20,17 @@ import java.util.List;
 
 public class DeathBackCommand implements EssentiaCommand {
 
-    static String commandName = "deathback";
+    @Override
+    public String commandName() {
+        return "deathback";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .executes((source) -> {

plugin/src/main/java/com/alttd/essentia/commands/player/DelHomeCommand.java

@@ -23,14 +23,17 @@ import java.util.Collection;
 
 public class DelHomeCommand implements EssentiaCommand {
 
-    static String commandName = "delhome";
+    @Override
+    public String commandName() {
+        return "delhome";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .executes((source) -> {
@@ -70,7 +73,7 @@ public class DelHomeCommand implements EssentiaCommand {
                         )
                         .then(
                                 Commands.argument("player", new OfflinePlayerArgument())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
                                         .then(
                                                 Commands.argument("home", StringArgumentType.word())
                                                         .suggests((context, suggestionsBuilder) -> {

plugin/src/main/java/com/alttd/essentia/commands/player/DisposeCommand.java

@@ -18,14 +18,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class DisposeCommand implements EssentiaCommand {
 
-    static String commandName = "dispose";
+    @Override
+    public String commandName() {
+        return "dispose";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission())
                         )
                         .executes((source) -> {
                             if (source.getSource().getSender() instanceof Player player)
@@ -35,7 +38,7 @@ public class DisposeCommand implements EssentiaCommand {
                         })
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/player/HomeCommand.java

@@ -26,14 +26,17 @@ import java.util.Collection;
 // TODO - home other
 public class HomeCommand implements EssentiaCommand {
 
-    static String commandName = "home";
+    @Override
+    public String commandName() {
+        return "home";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .executes((source) -> {

plugin/src/main/java/com/alttd/essentia/commands/player/HomeListCommand.java

@@ -19,14 +19,17 @@ import java.util.List;
 
 public class HomeListCommand implements EssentiaCommand {
 
-    static String commandName = "homelist";
+    @Override
+    public String commandName() {
+        return "homelist";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission())
                         )
                         .executes((source) -> {
                             if (source.getSource().getSender() instanceof Player player)
@@ -36,7 +39,7 @@ public class HomeListCommand implements EssentiaCommand {
                         })
                         .then(
                                 Commands.argument("player", new OfflinePlayerCompletingArgument())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
                                         .executes((source) -> {
                                             OfflinePlayer target = source.getArgument("player", OfflinePlayer.class);
                                             execute(source.getSource().getSender(), target);

plugin/src/main/java/com/alttd/essentia/commands/player/SetHomeCommand.java

@@ -20,14 +20,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class SetHomeCommand implements EssentiaCommand {
 
-    static String commandName = "sethome";
+    @Override
+    public String commandName() {
+        return "sethome";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .executes((source) -> {
@@ -49,7 +52,7 @@ public class SetHomeCommand implements EssentiaCommand {
                         )
                         .then(
                                 Commands.argument("player", new OfflinePlayerArgument())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
                                         .then(
                                                 Commands.argument("name", StringArgumentType.word())
                                                         .executes((source) -> {

plugin/src/main/java/com/alttd/essentia/commands/player/SpawnCommand.java

@@ -21,14 +21,17 @@ import org.jetbrains.annotations.NotNull;
 
 public class SpawnCommand implements EssentiaCommand {
 
-    static String commandName = "spawn";
+    @Override
+    public String commandName() {
+        return "spawn";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission())
                         )
                         .executes((source) -> {
                             if (source.getSource().getSender() instanceof Player player)
@@ -38,7 +41,7 @@ public class SpawnCommand implements EssentiaCommand {
                         })
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/commands/player/TeleportAcceptCommand.java

@@ -16,14 +16,17 @@ import java.util.List;
 
 public class TeleportAcceptCommand implements EssentiaCommand {
 
-    static String commandName = "teleportaccept";
+    @Override
+    public String commandName() {
+        return "teleportaccept";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .executes((source) -> {

plugin/src/main/java/com/alttd/essentia/commands/player/TeleportDenyCommand.java

@@ -16,14 +16,17 @@ import java.util.List;
 
 public class TeleportDenyCommand implements EssentiaCommand {
 
-    static String commandName = "teleportdeny";
+    @Override
+    public String commandName() {
+        return "teleportdeny";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .executes((source) -> {

plugin/src/main/java/com/alttd/essentia/commands/player/TeleportRequestCommand.java

@@ -20,19 +20,22 @@ import java.util.List;
 
 public class TeleportRequestCommand implements EssentiaCommand {
 
-    static String commandName = "teleportrequesthere";
+    @Override
+    public String commandName() {
+        return "teleportrequesthere";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
                                         .executes((source) -> {
                                             if (!(source.getSource().getSender() instanceof Player player))
                                                 return 1;

plugin/src/main/java/com/alttd/essentia/commands/player/TeleportRequestHereCommand.java

@@ -20,19 +20,22 @@ import java.util.List;
 
 public class TeleportRequestHereCommand implements EssentiaCommand {
 
-    static String commandName = "teleportrequesthere";
+    @Override
+    public String commandName() {
+        return "teleportrequesthere";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName) &&
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission()) &&
                                         commandSourceStack.getSender() instanceof Player
                         )
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
                                         .executes((source) -> {
                                             if (!(source.getSource().getSender() instanceof Player player))
                                                 return 1;

plugin/src/main/java/com/alttd/essentia/commands/player/TeleportToggleCommand.java

@@ -21,14 +21,17 @@ import java.util.List;
 
 public class TeleportToggleCommand implements EssentiaCommand {
 
-    static String commandName = "teleporttoggle";
+    @Override
+    public String commandName() {
+        return "teleporttoggle";
+    }
 
     @Override
     public @NotNull LiteralCommandNode<CommandSourceStack> command() {
         final LiteralArgumentBuilder<CommandSourceStack> builder =
-                Commands.literal(commandName)
+                Commands.literal(commandName())
                         .requires(
-                                commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName)
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(baseCommandPermission())
                         )
                         .executes((source) -> {
                             if (source.getSource().getSender() instanceof Player player)
@@ -38,7 +41,7 @@ public class TeleportToggleCommand implements EssentiaCommand {
                         })
                         .then(
                                 Commands.argument("player", ArgumentTypes.player())
-                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission("essentia.command.player." + commandName + ".other"))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(baseOtherCommandPermission()))
                                         .executes((source) -> {
                                             CommandSourceStack sourceStack = source.getSource();
                                             Player target = source.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(sourceStack).getFirst();

plugin/src/main/java/com/alttd/essentia/configuration/Config.java

@@ -2,7 +2,6 @@ package com.alttd.essentia.configuration;
 
 import com.alttd.essentia.EssentiaPlugin;
 import com.google.common.base.Throwables;
-import org.bukkit.Bukkit;
 import org.bukkit.Sound;
 import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.YamlConfiguration;
@@ -66,7 +65,7 @@ public class Config {
         saveConfig();
     }
 
-    static void saveConfig() {
+    public static void saveConfig() {
         try {
             config.save(CONFIG_FILE);
         } catch (IOException ex) {