Stub for SavedInventory

api/src/main/java/com/alttd/essentia/EssentiaAPI.java

@@ -1,5 +1,6 @@
 package com.alttd.essentia;
 
+import com.alttd.essentia.api.model.randomteleport.LocationValidator;
 import org.jetbrains.annotations.ApiStatus;
 
 public interface EssentiaAPI {
@@ -19,4 +20,6 @@ public interface EssentiaAPI {
             Provider.instance = instance;
         }
     }
+
+    public void addLocationValidator(LocationValidator locationValidator);
 }

api/src/main/java/com/alttd/essentia/api/events/player/PlayerRandomTeleportEvent.java

@@ -0,0 +1,40 @@
+package com.alttd.essentia.api.events.player;
+
+import com.alttd.essentia.api.events.EssentiaEvent;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+public class PlayerRandomTeleportEvent extends EssentiaEvent {
+
+    private static final HandlerList handlerList = new HandlerList();
+
+    private final Player player;
+    private final Location location;
+
+    public PlayerRandomTeleportEvent(Player player, Location location) {
+        this.player = player;
+        this.location = location;
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
+
+    public Location getLocation() {
+        return location;
+    }
+
+    @NotNull
+    @Override
+    public HandlerList getHandlers() {
+        return handlerList;
+    }
+
+    @NotNull
+    public static HandlerList getHandlerList() {
+        return handlerList;
+    }
+
+}

api/src/main/java/com/alttd/essentia/api/events/player/PlayerRemoveHomeEvent.java

@@ -1,5 +1,6 @@
-package com.alttd.essentia.api.events;
+package com.alttd.essentia.api.events.player;
 
+import com.alttd.essentia.api.events.EssentiaEvent;
 import org.bukkit.entity.Player;
 import org.bukkit.event.HandlerList;
 import org.jetbrains.annotations.NotNull;

api/src/main/java/com/alttd/essentia/api/events/player/PlayerSetHomeEvent.java

@@ -1,5 +1,6 @@
-package com.alttd.essentia.api.events;
+package com.alttd.essentia.api.events.player;
 
+import com.alttd.essentia.api.events.EssentiaEvent;
 import org.bukkit.Location;
 import org.bukkit.entity.Player;
 import org.bukkit.event.HandlerList;

api/src/main/java/com/alttd/essentia/api/events/player/PlayerTeleportBackEvent.java

@@ -1,5 +1,6 @@
-package com.alttd.essentia.api.events;
+package com.alttd.essentia.api.events.player;
 
+import com.alttd.essentia.api.events.EssentiaEvent;
 import org.bukkit.Location;
 import org.bukkit.entity.Player;
 import org.bukkit.event.HandlerList;

api/src/main/java/com/alttd/essentia/api/events/player/PlayerTeleportHomeEvent.java

@@ -1,5 +1,6 @@
-package com.alttd.essentia.api.events;
+package com.alttd.essentia.api.events.player;
 
+import com.alttd.essentia.api.events.EssentiaEvent;
 import org.bukkit.Location;
 import org.bukkit.entity.Player;
 import org.bukkit.event.HandlerList;

api/src/main/java/com/alttd/essentia/api/events/player/PlayerTeleportSpawnEvent.java

@@ -1,5 +1,6 @@
-package com.alttd.essentia.api.events;
+package com.alttd.essentia.api.events.player;
 
+import com.alttd.essentia.api.events.EssentiaEvent;
 import org.bukkit.Location;
 import org.bukkit.entity.Player;
 import org.bukkit.event.HandlerList;

api/src/main/java/com/alttd/essentia/api/model/MobData.java

@@ -0,0 +1,23 @@
+package com.alttd.essentia.api.model;
+
+public enum MobData {
+
+    ITEMS,
+    ARROWS,
+    BOATS,
+    MINECARTS,
+    XP,
+    PAINTINGS,
+    ITEMFRAMES,
+    ENDERCRYSTALS,
+    FIREWORKS,
+    HOSTILE,
+    MONSTERS,
+    PASSIVE,
+    ANIMALS,
+    AMBIENT,
+    MOBS,
+    ENTITIES,
+    TAMED
+
+}

api/src/main/java/com/alttd/essentia/api/model/randomteleport/LocationValidator.java

@@ -0,0 +1,8 @@
+package com.alttd.essentia.api.model.randomteleport;
+
+import org.bukkit.Location;
+
+public interface LocationValidator {
+
+    boolean validate(Location location);
+}

plugin/build.gradle.kts

@@ -5,7 +5,7 @@ plugins {
 
 dependencies {
     implementation(project(":api"))
-    compileOnly("com.alttd:Galaxy-API:1.21.1-R0.1-SNAPSHOT")
+    compileOnly("com.alttd.cosmos:cosmos-api:1.21.6-R0.1-SNAPSHOT")
     api("org.reflections:reflections:0.10.2")
 
     compileOnly("org.projectlombok:lombok:1.18.34")

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

@@ -2,11 +2,15 @@ package com.alttd.essentia;
 
 import com.alttd.essentia.commands.EssentiaCommand;
 import com.alttd.essentia.configuration.Config;
+import com.alttd.essentia.api.model.randomteleport.LocationValidator;
+import com.alttd.essentia.feature.Features;
+import com.alttd.essentia.model.annotations.Depends;
 import com.alttd.essentia.storage.StorageManager;
 import com.alttd.essentia.storage.StorageProvider;
 import com.alttd.essentia.storage.StorageType;
 import com.alttd.essentia.user.EssentiaUserManager;
 import com.alttd.essentia.api.user.UserManager;
+import com.alttd.essentia.util.Timer;
 import io.papermc.paper.command.brigadier.Commands;
 import io.papermc.paper.plugin.lifecycle.event.LifecycleEventManager;
 import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents;
@@ -18,6 +22,8 @@ import org.bukkit.plugin.java.JavaPlugin;
 import org.reflections.Reflections;
 import org.reflections.scanners.Scanners;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Set;
 
 public class EssentiaPlugin extends JavaPlugin implements EssentiaAPI {
@@ -27,10 +33,15 @@ public class EssentiaPlugin extends JavaPlugin implements EssentiaAPI {
 
     @Getter
     private UserManager userManager;
+    @Getter
+    private List<LocationValidator> locationValidators;
 
     @Getter
     private StorageProvider storageProvider;
 
+    @Getter
+    private Features features;
+
     @Override
     public void onLoad() {
         instance = this;
@@ -39,11 +50,15 @@ public class EssentiaPlugin extends JavaPlugin implements EssentiaAPI {
 
     @Override
     public void onEnable() {
-        loadConfiguration();
-        loadCommands();
-        loadEventListeners();
-        loadManagers();
-        loadStorageProvider();
+        new Timer("onEnable", () -> {
+            new Timer("loadConfiguration", this::loadConfiguration);
+            new Timer("loadFeatures", this::loadFeatures);
+            new Timer("loadCommands", this::loadCommands);
+            new Timer("loadEventListeners", this::loadEventListeners);
+            new Timer("loadManagers", this::loadManagers);
+            new Timer("loadStorageProvider", this::loadStorageProvider);
+            new Timer("loadLocationValidators", this::loadLocationValidators);
+        });
     }
 
     @Override
@@ -57,8 +72,13 @@ public class EssentiaPlugin extends JavaPlugin implements EssentiaAPI {
         Config.init();
     }
 
+    public void loadFeatures() {
+        features = new Features(this);
+        features.registerAll();
+    }
+
     void loadCommands() {
-        Reflections reflections = new Reflections("com.alttd.essentia.commands.list");
+        Reflections reflections = new Reflections("com.alttd.essentia.commands");
         Set<Class<?>> subTypes = reflections.get(Scanners.SubTypes.of(EssentiaCommand.class).asClass());
 
         LifecycleEventManager<Plugin> manager = this.getLifecycleManager();
@@ -67,6 +87,13 @@ public class EssentiaPlugin extends JavaPlugin implements EssentiaAPI {
             subTypes.forEach(clazz -> {
                 try {
                     EssentiaCommand essentiaCommand = (EssentiaCommand) clazz.getDeclaredConstructor().newInstance();
+                    final Depends depends = clazz.getAnnotation(Depends.class);
+                    if (depends != null) {
+                        if (!features.isEnabled(depends.value())) {
+                            return;
+                        }
+                    }
+
                     commands.register(essentiaCommand.command(), essentiaCommand.description(), essentiaCommand.aliases());
                 } catch (Exception e) {
                     EssentiaPlugin.instance().getLogger().severe("Failed to register command " + clazz.getSimpleName());
@@ -77,12 +104,21 @@ public class EssentiaPlugin extends JavaPlugin implements EssentiaAPI {
 
     void loadEventListeners() {
         final PluginManager pluginManager = getServer().getPluginManager();
-        Reflections reflections = new Reflections("com.alttd.essentia.listeners");
+        Reflections reflections = new Reflections("com.alttd.essentia.listeners"); // These are plugin required listeners eg player data loading on login.
         Set<Class<?>> subTypes = reflections.get(Scanners.SubTypes.of(Listener.class).asClass());
+        reflections = new Reflections("com.alttd.essentia.feature"); // These are them listeners for the features.
+        subTypes.addAll(reflections.get(Scanners.SubTypes.of(Listener.class).asClass()));
 
         subTypes.forEach(clazz -> {
             try {
                 Listener listener = (Listener) clazz.getDeclaredConstructor().newInstance();
+                final Depends depends = clazz.getAnnotation(Depends.class);
+                if (depends != null) {
+                    if (!features.isEnabled(depends.value())) {
+                        return;
+                    }
+                }
+
                 pluginManager.registerEvents(listener, this);
             } catch (Exception e) {
                 EssentiaPlugin.instance().getLogger().severe("Failed to register event listener " + clazz.getSimpleName());
@@ -100,4 +136,26 @@ public class EssentiaPlugin extends JavaPlugin implements EssentiaAPI {
         storageProvider.startAutoSaving();
     }
 
+    void loadLocationValidators() {
+        this.locationValidators = new ArrayList<>();
+        Reflections reflections = new Reflections("com.alttd.essentia.feature.randomteleport.validator");
+        Set<Class<?>> subTypes = reflections.get(Scanners.SubTypes.of(LocationValidator.class).asClass());
+
+        subTypes.forEach(clazz -> {
+            try {
+                LocationValidator locationValidator = (LocationValidator) clazz.getDeclaredConstructor().newInstance();
+                addLocationValidator(locationValidator);
+            } catch (Exception e) {
+                EssentiaPlugin.instance().getLogger().severe("Failed to add locationValidator " + clazz.getSimpleName());
+                EssentiaPlugin.instance().getLogger().severe(e.getMessage());
+            }
+        });
+    }
+
+    // TODO -- make this reload proof for API
+    @Override
+    public void addLocationValidator(LocationValidator locationValidator) {
+        locationValidators.add(locationValidator);
+    }
+
 }

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

@@ -0,0 +1,41 @@
+package com.alttd.essentia.commands;
+
+import com.alttd.essentia.util.Pair;
+import com.mojang.brigadier.Message;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+
+import java.util.Collection;
+import java.util.concurrent.CompletableFuture;
+
+public interface EssentiaArgument {
+
+    default <S> CompletableFuture<Suggestions> completedFuture(SuggestionsBuilder builder, Collection<String> possibleValues) {
+        String remaining = builder.getRemaining().toLowerCase();
+        for (String str : possibleValues) {
+            if (str.toLowerCase().startsWith(remaining)) {
+                builder.suggest(StringArgumentType.escapeIfRequired(str));
+            }
+        }
+
+        return CompletableFuture.completedFuture(
+                builder.build()
+        );
+    }
+
+    default <S> CompletableFuture<Suggestions> completedFuturePair(SuggestionsBuilder builder, Collection<Pair<String, Message>> possibleValues) {
+        String remaining = builder.getRemaining().toLowerCase();
+        for (Pair<String, Message> pair : possibleValues) {
+            String str = pair.x();
+            if (str.toLowerCase().startsWith(remaining)) {
+                builder.suggest(StringArgumentType.escapeIfRequired(str), pair.y());
+            }
+        }
+
+        return CompletableFuture.completedFuture(
+                builder.build()
+        );
+    }
+
+}

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

@@ -1,7 +1,6 @@
 package com.alttd.essentia.commands.admin;
 
 import com.alttd.essentia.commands.EssentiaCommand;
-import com.alttd.essentia.commands.argumement.EnchantmentArgument;
 import com.mojang.brigadier.arguments.IntegerArgumentType;
 import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.tree.LiteralCommandNode;
@@ -9,6 +8,7 @@ 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 io.papermc.paper.registry.RegistryKey;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
 import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import org.bukkit.Material;
@@ -33,7 +33,7 @@ public class EnchantCommand implements EssentiaCommand {
                                 commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
                         )
                         .then(
-                                Commands.argument("enchantment", new EnchantmentArgument())
+                                Commands.argument("enchantment", ArgumentTypes.resource(RegistryKey.ENCHANTMENT))
                                         .executes((source) -> {
                                             if (!(source.getSource().getSender() instanceof Player player))
                                                 return 1;

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

@@ -0,0 +1,246 @@
+package com.alttd.essentia.commands.admin;
+
+import com.alttd.essentia.api.model.MobData;
+import com.alttd.essentia.commands.EssentiaCommand;
+import com.alttd.essentia.commands.argumement.EntityTypeArgumentType;
+import com.alttd.essentia.commands.argumement.MobDataArgumentType;
+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 net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.*;
+import org.jetbrains.annotations.NotNull;
+
+public class KillallCommand implements EssentiaCommand {
+
+    @Override
+    public String commandName() {
+        return "killall";
+    }
+
+    @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.argument("mobdata", new MobDataArgumentType())
+                                .executes((source) -> {
+                                    if (!(source.getSource().getSender() instanceof Player player))
+                                        return 1;
+
+                                    MobData mobData = source.getArgument("mobdata", MobData.class);
+                                    execute(source.getSource().getSender(), player, mobData, 50, false);
+                                    return 1;
+                                })
+                                .then(Commands.argument("radius", IntegerArgumentType.integer(0, 250))
+                                        .executes((source) -> {
+                                            if (!(source.getSource().getSender() instanceof Player player))
+                                                return 1;
+
+                                            MobData mobData = source.getArgument("mobdata", MobData.class);
+                                            int radius = source.getArgument("radius", Integer.class);
+                                            execute(source.getSource().getSender(), player, mobData, radius, false);
+                                            return 1;
+                                        })
+                                        .then(Commands.literal("named")
+                                            .executes((source) -> {
+                                                if (!(source.getSource().getSender() instanceof Player player))
+                                                    return 1;
+
+                                                MobData mobData = source.getArgument("mobdata", MobData.class);
+                                                int radius = source.getArgument("range", Integer.class);
+                                                execute(source.getSource().getSender(), player, mobData, radius, true);
+                                                return 1;
+                                            })
+                                        )
+
+                                )
+                        )
+//                        .then(Commands.argument("entitytype", new EntityTypeArgumentType())
+//                                .executes((source) -> {
+//                                    if (!(source.getSource().getSender() instanceof Player player))
+//                                        return 1;
+//
+//                                    EntityType entityType = source.getArgument("entitytype", EntityType.class);
+//                                    execute(source.getSource().getSender(), player, entityType, 50, false);
+//                                    return 1;
+//                                })
+//                                .then(Commands.argument("radius", IntegerArgumentType.integer(0, 250))
+//                                        .executes((source) -> {
+//                                            if (!(source.getSource().getSender() instanceof Player player))
+//                                                return 1;
+//
+//                                            EntityType entityType = source.getArgument("entitytype", EntityType.class);
+//                                            int radius = source.getArgument("radius", Integer.class);
+//                                            execute(source.getSource().getSender(), player, entityType, radius, false);
+//                                            return 1;
+//                                        })
+//                                        .then(Commands.literal("named")
+//                                                .executes((source) -> {
+//                                                    if (!(source.getSource().getSender() instanceof Player player))
+//                                                        return 1;
+//
+//                                                    EntityType entityType = source.getArgument("entitytype", EntityType.class);
+//                                                    int radius = source.getArgument("range", Integer.class);
+//                                                    execute(source.getSource().getSender(), player, entityType, radius, true);
+//                                                    return 1;
+//                                                })
+//                                        )
+//
+//                                )
+//                        )
+                ;
+        return builder.build();
+    }
+
+    public void execute(CommandSender sender, Player target, MobData mobData, int radius, boolean named) { // TODO - Messages from config, placeholders
+        TagResolver placeholders = TagResolver.resolver(
+                Placeholder.component("requester", sender.name()),
+                Placeholder.component("target", target.displayName())
+        );
+
+        int removed = 0;
+
+        for (Entity entity : target.getNearbyEntities(radius, radius, radius)) {
+            if (entity instanceof HumanEntity)
+                continue;
+
+            // PERFORMANCE hit?
+            if (entity instanceof Tameable tameable && (tameable.isTamed() && tameable.getOwner() instanceof Player || tameable.getOwner() instanceof OfflinePlayer) && mobData != MobData.TAMED)
+                continue;
+
+            // TODO - named entities
+            if (entity instanceof LivingEntity && entity.customName() != null)
+                continue;
+
+            switch (mobData) {
+                case ITEMS -> {
+                    if (entity instanceof Item) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case ARROWS -> {
+                    if (entity instanceof Projectile) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case BOATS ->  {
+                    if (entity instanceof Boat) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case MINECARTS ->  {
+                    if (entity instanceof Minecart) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case XP ->  {
+                    if (entity instanceof ExperienceOrb) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case PAINTINGS ->  {
+                    if (entity instanceof Painting) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case ITEMFRAMES ->  {
+                    if (entity instanceof ItemFrame) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case ENDERCRYSTALS ->  {
+                    if (entity instanceof EnderCrystal) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case FIREWORKS ->  {
+                    if (entity instanceof Firework) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case HOSTILE, MONSTERS ->  {
+                    if (entity instanceof Monster ||entity instanceof ComplexLivingEntity || entity instanceof Flying || entity instanceof Slime) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case PASSIVE, ANIMALS ->  {
+                    if (entity instanceof Animals || entity instanceof Snowman || entity instanceof WaterMob || entity instanceof Ambient) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case AMBIENT ->  {
+                    if (entity instanceof Ambient) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case MOBS ->  {
+                    if (entity instanceof Monster ||entity instanceof ComplexLivingEntity || entity instanceof Flying || entity instanceof Slime || entity instanceof Animals || entity instanceof Snowman || entity instanceof WaterMob || entity instanceof Ambient) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+                case ENTITIES ->  {
+                    entity.remove();
+                    removed++;
+                }
+                case TAMED ->  {
+                    if (entity instanceof Tameable tameable && tameable.isTamed()) {
+                        entity.remove();
+                        removed++;
+                    }
+                }
+            }
+        }
+
+    }
+
+    public void execute(CommandSender sender, Player target, EntityType entityType, int radius, boolean named) { // TODO - Messages from config, placeholders
+        TagResolver placeholders = TagResolver.resolver(
+                Placeholder.component("requester", sender.name()),
+                Placeholder.component("target", target.displayName())
+        );
+
+        int removed = 0;
+
+        for (Entity entity : target.getNearbyEntities(radius, radius, radius)) {
+            if (entity instanceof HumanEntity)
+                continue;
+
+            // PERFORMANCE hit?
+            if (entity instanceof Tameable tameable && (tameable.isTamed() && tameable.getOwner() instanceof Player || tameable.getOwner() instanceof OfflinePlayer))
+                continue;
+
+            // TODO - named entities
+            if (entity instanceof LivingEntity && entity.customName() != null)
+                continue;
+
+            if (entity.getType() == entityType) {
+                entity.remove();
+                removed++;
+            }
+        }
+
+    }
+
+}

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

@@ -0,0 +1,58 @@
+package com.alttd.essentia.commands.admin;
+
+import com.alttd.essentia.EssentiaPlugin;
+import com.alttd.essentia.commands.EssentiaCommand;
+import com.alttd.essentia.request.RandomTeleportRequest;
+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.jetbrains.annotations.NotNull;
+
+public class RandomTeleportCommand implements EssentiaCommand {
+
+    @Override
+    public String commandName() {
+        return "randomteleport";
+    }
+
+    @Override
+    public @NotNull LiteralCommandNode<CommandSourceStack> command() {
+        final LiteralArgumentBuilder<CommandSourceStack> builder =
+                Commands.literal(commandName())
+                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission()))
+                        .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();
+                                            execute(source.getSource().getSender(), target);
+
+                                            return 1;
+                                        })
+                                );
+        return builder.build();
+    }
+
+    @Override
+    public String description() {
+        return "Teleport a player to a random location!";
+    }
+
+    public void execute(CommandSender sender, Player target) { // TODO - messages
+        TagResolver placeholders = TagResolver.resolver(
+                Placeholder.component("requester", sender.name()),
+                Placeholder.component("target", target.displayName())
+        );
+
+        new RandomTeleportRequest(EssentiaPlugin.instance(), target, target);
+    }
+
+}

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

@@ -0,0 +1,55 @@
+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 io.papermc.paper.command.brigadier.argument.ArgumentTypes;
+import io.papermc.paper.registry.RegistryKey;
+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.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.jetbrains.annotations.NotNull;
+
+// TODO -- FINISH ME - messages and options?
+public class SpawnMobCommand implements EssentiaCommand {
+
+    @Override
+    public String commandName() {
+        return "spawnmob";
+    }
+
+    @Override
+    public @NotNull LiteralCommandNode<CommandSourceStack> command() {
+        final LiteralArgumentBuilder<CommandSourceStack> builder =
+                Commands.literal(commandName())
+                        .requires(
+                                commandSourceStack -> commandSourceStack.getSender().hasPermission(adminCommandPermission())
+                        )
+                        .then(
+                                Commands.argument("entity", ArgumentTypes.resource(RegistryKey.ENTITY_TYPE))
+                                        .requires(commandSourceStack -> commandSourceStack.getSender().hasPermission(adminOtherCommandPermission()))
+                                        .executes((source) -> {
+                                            EntityType entityType = source.getArgument("entity", EntityType.class);
+                                            execute(source.getSource().getSender(), (Player) source.getSource().getSender(), entityType);
+
+                                            return 1;
+                                        })
+                        );
+        return builder.build();
+    }
+
+    public void execute(CommandSender sender, Player target, EntityType entityType) { // TODO - implement player info
+        TagResolver placeholders = TagResolver.resolver(
+                Placeholder.component("requester", sender.name()),
+                Placeholder.component("target", target.displayName())
+        );
+
+        target.getWorld().spawn(target.getLocation(), entityType.getEntityClass(), CreatureSpawnEvent.SpawnReason.COMMAND);
+    }
+
+}

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

@@ -0,0 +1,52 @@
+package com.alttd.essentia.commands.argumement;
+
+import com.alttd.essentia.commands.EssentiaArgument;
+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.entity.EntityType;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.concurrent.CompletableFuture;
+
+// TODO -- add a wrapper for entitytype and only list those we want to list as this large list breaks tabcomplete
+public class EntityTypeArgumentType implements CustomArgumentType.Converted<EntityType, String>, EssentiaArgument {
+
+    @Override
+    public @NotNull EntityType convert(String nativeType) throws CommandSyntaxException {
+        try {
+            return EntityType.valueOf(nativeType.toUpperCase());
+        } catch (Exception e) {
+            Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid EntityType %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) {
+        Collection<String> possibleValues = new ArrayList<>();
+        for (EntityType entityType : EntityType.values()) {
+            possibleValues.add(entityType.name().toLowerCase());
+        }
+
+        return completedFuture(builder, possibleValues);
+    }
+
+}

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

@@ -1,5 +1,6 @@
 package com.alttd.essentia.commands.argumement;
 
+import com.alttd.essentia.commands.EssentiaArgument;
 import com.mojang.brigadier.Message;
 import com.mojang.brigadier.arguments.ArgumentType;
 import com.mojang.brigadier.arguments.StringArgumentType;
@@ -15,9 +16,11 @@ import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.inventory.EquipmentSlot;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.concurrent.CompletableFuture;
 
-public class EquipmentArgumentType implements CustomArgumentType.Converted<EquipmentSlot, String> {
+public class EquipmentArgumentType implements CustomArgumentType.Converted<EquipmentSlot, String>, EssentiaArgument {
 
     @Override
     public @NotNull EquipmentSlot convert(String nativeType) throws CommandSyntaxException {
@@ -37,13 +40,15 @@ public class EquipmentArgumentType implements CustomArgumentType.Converted<Equip
 
     @Override
     public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
+        Collection<String> possibleValues = new ArrayList<>();
         for (EquipmentSlot equipmentSlot : EquipmentSlot.values()) {
-            builder.suggest(equipmentSlot.name().toLowerCase());
+            if (!equipmentSlot.isHand() || !equipmentSlot.isArmor())
+                continue;
+
+            possibleValues.add(equipmentSlot.name().toLowerCase());
         }
 
-        return CompletableFuture.completedFuture(
-                builder.build()
-        );
+        return completedFuture(builder, possibleValues);
     }
 
 }

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

@@ -1,5 +1,7 @@
 package com.alttd.essentia.commands.argumement;
 
+import com.alttd.essentia.api.model.MobData;
+import com.alttd.essentia.commands.EssentiaArgument;
 import com.mojang.brigadier.Message;
 import com.mojang.brigadier.arguments.ArgumentType;
 import com.mojang.brigadier.arguments.StringArgumentType;
@@ -10,24 +12,22 @@ 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 io.papermc.paper.registry.RegistryAccess;
-import io.papermc.paper.registry.RegistryKey;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
-import org.bukkit.NamespacedKey;
-import org.bukkit.enchantments.Enchantment;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.concurrent.CompletableFuture;
 
-public class EnchantmentArgument implements CustomArgumentType.Converted<Enchantment, String> {
+public class MobDataArgumentType implements CustomArgumentType.Converted<MobData, String>, EssentiaArgument {
 
     @Override
-    public @NotNull Enchantment convert(String nativeType) throws CommandSyntaxException {
+    public @NotNull MobData convert(String nativeType) throws CommandSyntaxException {
         try {
-            return Enchantment.getByKey(NamespacedKey.minecraft(nativeType));
+            return MobData.valueOf(nativeType.toUpperCase());
         } catch (Exception e) {
-            Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid enchantment %s!".formatted(nativeType), NamedTextColor.RED));
+            Message message = MessageComponentSerializer.message().serialize(Component.text("Invalid mobdatatype %s!".formatted(nativeType), NamedTextColor.RED));
 
             throw new CommandSyntaxException(new SimpleCommandExceptionType(message), message);
         }
@@ -40,12 +40,12 @@ public class EnchantmentArgument implements CustomArgumentType.Converted<Enchant
 
     @Override
     public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
-        for (Enchantment enchantment : RegistryAccess.registryAccess().getRegistry(RegistryKey.ENCHANTMENT)) {
-            builder.suggest(enchantment.getKey().value());
+        Collection<String> possibleValues = new ArrayList<>();
+        for (MobData mobData : MobData.values()) {
+            possibleValues.add(mobData.name().toLowerCase());
         }
 
-        return CompletableFuture.completedFuture(
-                builder.build()
-        );
+        return completedFuture(builder, possibleValues);
     }
-}
+
+}

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

@@ -1,5 +1,7 @@
 package com.alttd.essentia.commands.argumement;
 
+import com.alttd.essentia.commands.EssentiaArgument;
+import com.alttd.essentia.util.Pair;
 import com.mojang.brigadier.Message;
 import com.mojang.brigadier.arguments.ArgumentType;
 import com.mojang.brigadier.arguments.StringArgumentType;
@@ -17,9 +19,11 @@ import org.bukkit.OfflinePlayer;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.concurrent.CompletableFuture;
 
-public class OfflinePlayerCompletingArgument implements CustomArgumentType.Converted<OfflinePlayer, String> {
+public class OfflinePlayerCompletingArgument implements CustomArgumentType.Converted<OfflinePlayer, String>, EssentiaArgument {
 
     @Override
     public @NotNull OfflinePlayer convert(String nativeType) throws CommandSyntaxException {
@@ -39,12 +43,11 @@ public class OfflinePlayerCompletingArgument implements CustomArgumentType.Conve
 
     @Override
     public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
+        Collection<Pair<String, Message>> possibleValues = new ArrayList<>();
         for (Player player : Bukkit.getOnlinePlayers()) {
-            builder.suggest(player.getName(), MessageComponentSerializer.message().serialize(player.displayName()));
+            possibleValues.add(new Pair<>(player.getName(), MessageComponentSerializer.message().serialize(player.displayName())));
         }
 
-        return CompletableFuture.completedFuture(
-                builder.build()
-        );
+        return completedFuturePair(builder, possibleValues);
     }
 }

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

@@ -1,5 +1,6 @@
 package com.alttd.essentia.commands.argumement;
 
+import com.alttd.essentia.commands.EssentiaArgument;
 import com.mojang.brigadier.Message;
 import com.mojang.brigadier.arguments.ArgumentType;
 import com.mojang.brigadier.arguments.StringArgumentType;
@@ -15,9 +16,11 @@ import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.WeatherType;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.concurrent.CompletableFuture;
 
-public class WeatherArgument implements CustomArgumentType.Converted<WeatherType, String> {
+public class WeatherArgument implements CustomArgumentType.Converted<WeatherType, String>, EssentiaArgument {
 
     @Override
     public @NotNull WeatherType convert(String nativeType) throws CommandSyntaxException {
@@ -37,12 +40,11 @@ public class WeatherArgument implements CustomArgumentType.Converted<WeatherType
 
     @Override
     public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
+        Collection<String> possibleValues = new ArrayList<>();
         for (WeatherType weatherType : WeatherType.values()) {
-            builder.suggest(weatherType.name().toLowerCase());
+            possibleValues.add(weatherType.name().toLowerCase());
         }
 
-        return CompletableFuture.completedFuture(
-                builder.build()
-        );
+        return completedFuture(builder, possibleValues);
     }
 }

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

@@ -2,7 +2,7 @@ package com.alttd.essentia.commands.player;
 
 import com.alttd.essentia.EssentiaPlugin;
 import com.alttd.essentia.api.events.EssentiaEvent;
-import com.alttd.essentia.api.events.PlayerTeleportBackEvent;
+import com.alttd.essentia.api.events.player.PlayerTeleportBackEvent;
 import com.alttd.essentia.api.user.User;
 import com.alttd.essentia.commands.EssentiaCommand;
 import com.alttd.essentia.configuration.Config;

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

@@ -4,7 +4,7 @@ import com.alttd.essentia.EssentiaPlugin;
 import com.alttd.essentia.commands.EssentiaCommand;
 import com.alttd.essentia.configuration.Config;
 import com.alttd.essentia.api.events.EssentiaEvent;
-import com.alttd.essentia.api.events.PlayerTeleportBackEvent;
+import com.alttd.essentia.api.events.player.PlayerTeleportBackEvent;
 import com.alttd.essentia.tasks.TeleportSounds;
 import com.alttd.essentia.api.user.User;
 import com.mojang.brigadier.builder.LiteralArgumentBuilder;

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

@@ -5,7 +5,7 @@ import com.alttd.essentia.commands.EssentiaCommand;
 import com.alttd.essentia.commands.argumement.OfflinePlayerArgument;
 import com.alttd.essentia.configuration.Config;
 import com.alttd.essentia.api.events.EssentiaEvent;
-import com.alttd.essentia.api.events.PlayerRemoveHomeEvent;
+import com.alttd.essentia.api.events.player.PlayerRemoveHomeEvent;
 import com.alttd.essentia.api.user.User;
 import com.mojang.brigadier.arguments.StringArgumentType;
 import com.mojang.brigadier.builder.LiteralArgumentBuilder;

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

@@ -2,7 +2,7 @@ package com.alttd.essentia.commands.player;
 
 import com.alttd.essentia.EssentiaPlugin;
 import com.alttd.essentia.api.events.EssentiaEvent;
-import com.alttd.essentia.api.events.PlayerTeleportHomeEvent;
+import com.alttd.essentia.api.events.player.PlayerTeleportHomeEvent;
 import com.alttd.essentia.api.model.Home;
 import com.alttd.essentia.commands.EssentiaCommand;
 import com.alttd.essentia.configuration.Config;

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

@@ -2,7 +2,7 @@ package com.alttd.essentia.commands.player;
 
 import com.alttd.essentia.EssentiaPlugin;
 import com.alttd.essentia.api.events.EssentiaEvent;
-import com.alttd.essentia.api.events.PlayerSetHomeEvent;
+import com.alttd.essentia.api.events.player.PlayerSetHomeEvent;
 import com.alttd.essentia.api.user.User;
 import com.alttd.essentia.commands.EssentiaCommand;
 import com.alttd.essentia.commands.argumement.OfflinePlayerArgument;

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

@@ -1,7 +1,7 @@
 package com.alttd.essentia.commands.player;
 
 import com.alttd.essentia.EssentiaPlugin;
-import com.alttd.essentia.api.events.PlayerTeleportSpawnEvent;
+import com.alttd.essentia.api.events.player.PlayerTeleportSpawnEvent;
 import com.alttd.essentia.commands.EssentiaCommand;
 import com.alttd.essentia.configuration.Config;
 import com.alttd.essentia.api.events.EssentiaEvent;

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

@@ -2,6 +2,8 @@ package com.alttd.essentia.configuration;
 
 import com.alttd.essentia.EssentiaPlugin;
 import com.google.common.base.Throwables;
+import it.unimi.dsi.fastutil.objects.Object2BooleanMap;
+import it.unimi.dsi.fastutil.objects.Object2BooleanOpenHashMap;
 import org.bukkit.Sound;
 import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.YamlConfiguration;
@@ -34,7 +36,7 @@ public class Config {
             config.load(CONFIG_FILE);
         } catch (IOException ignore) {
         } catch (InvalidConfigurationException ex) {
-            EssentiaPlugin.instance().getLogger().log(Level.SEVERE, "Could not load config.yml, please correct your syntax errors", ex);
+            log(Level.SEVERE, "Could not load config.yml, please correct your syntax errors", ex);
             Throwables.throwIfUnchecked(ex);
         }
         config.options().header(HEADER);
@@ -43,7 +45,7 @@ public class Config {
         version = getInt("config-version", 1);
         set("config-version", 1);
 
-        EssentiaPlugin.instance().getLogger().info("Essentia Configuration loaded!");
+        log(Level.INFO,"Essentia Configuration loaded!");
         readConfig(Config.class, null);
     }
 
@@ -57,7 +59,7 @@ public class Config {
                     } catch (InvocationTargetException ex) {
                         Throwables.throwIfUnchecked(ex);
                     } catch (Exception ex) {
-                        EssentiaPlugin.instance().getLogger().log(Level.SEVERE, "Error invoking " + method, ex);
+                        log(Level.SEVERE, "Error invoking " + method, ex);
                     }
                 }
             }
@@ -69,7 +71,7 @@ public class Config {
         try {
             config.save(CONFIG_FILE);
         } catch (IOException ex) {
-            EssentiaPlugin.instance().getLogger().log(Level.SEVERE, "Could not save " + CONFIG_FILE, ex);
+            log(Level.SEVERE, "Could not save " + CONFIG_FILE, ex);
         }
     }
 
@@ -107,6 +109,10 @@ public class Config {
         EssentiaPlugin.instance().getLogger().log(level, s);
     }
 
+    protected static void log(Level level, String s, Throwable thrown) {
+        EssentiaPlugin.instance().getLogger().log(level, s, thrown);
+    }
+
     public static int TELEPORT_REQUEST_TIMEOUT = 30;
     public static boolean TELEPORT_REQUEST_TIMEOUT_MESSAGES = true;
     public static boolean BACK_ON_DEATH = false;
@@ -270,4 +276,10 @@ public class Config {
         MYSQL_PASSWORD = getString("storage.mysql.password", MYSQL_PASSWORD);
     }
 
+    public static Object2BooleanMap<String> enabledFeatures = new Object2BooleanOpenHashMap<>();
+    private static void features() {
+        enabledFeatures.clear();
+        enabledFeatures.defaultReturnValue(true);
+    }
+
 }

plugin/src/main/java/com/alttd/essentia/feature/EssentiaFeature.java

@@ -0,0 +1,19 @@
+package com.alttd.essentia.feature;
+
+public interface EssentiaFeature {
+
+    String featureName();
+
+    void register();
+
+    boolean isEnabled();
+
+    default void start() {}
+
+    default void stop() {}
+
+    default void reload() {
+        stop();
+        start();
+    }
+}

plugin/src/main/java/com/alttd/essentia/feature/Features.java

@@ -0,0 +1,57 @@
+package com.alttd.essentia.feature;
+
+import com.alttd.essentia.EssentiaPlugin;
+import com.alttd.essentia.configuration.Config;
+import org.reflections.Reflections;
+import org.reflections.scanners.Scanners;
+
+import java.util.*;
+import java.util.logging.Level;
+
+public class Features {
+
+    private final EssentiaPlugin plugin;
+    private final Map<String, EssentiaFeature> features;
+
+    public Features(EssentiaPlugin plugin) {
+        this.plugin = plugin;
+        features = new HashMap<>();
+    }
+
+    public boolean isEnabled(String featureName) {
+        if (features.containsKey(featureName)) {
+            return features.get(featureName).isEnabled();
+        }
+        return false;
+    }
+
+    public void registerAll() {
+        Reflections reflections = new Reflections("com.alttd.essentia.feature");
+        Set<Class<?>> subTypes = reflections.get(Scanners.SubTypes.of(EssentiaFeature.class).asClass());
+
+        subTypes.forEach(clazz -> {
+            try {
+                EssentiaFeature essentiaFeature = (EssentiaFeature) clazz.getDeclaredConstructor().newInstance();
+                if (!Config.enabledFeatures.getBoolean(essentiaFeature.featureName())) {
+                    return;
+                }
+
+                essentiaFeature.register();
+                essentiaFeature.reload();
+
+                features.putIfAbsent(essentiaFeature.featureName(), essentiaFeature);
+            } catch (Exception e) {
+                log(Level.SEVERE,"Failed to register feature " + clazz.getSimpleName(), e);
+            }
+        });
+    }
+
+    protected void log(Level level, String s) {
+        plugin.getLogger().log(level, s);
+    }
+
+    protected void log(Level level, String s, Throwable thrown) {
+        plugin.getLogger().log(level, s, thrown);
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/feature/cuff/CuffFeature.java

@@ -0,0 +1,30 @@
+package com.alttd.essentia.feature.cuff;
+
+import com.alttd.essentia.EssentiaPlugin;
+import com.alttd.essentia.feature.EssentiaFeature;
+
+public class CuffFeature implements EssentiaFeature {
+
+    private final EssentiaPlugin plugin;
+
+    private boolean enabled = false;
+
+    public CuffFeature() {
+        this.plugin = EssentiaPlugin.instance();
+    }
+
+    @Override
+    public String featureName() {
+        return "cuff";
+    }
+
+    @Override
+    public void register() {
+        this.enabled = true;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return enabled;
+    }
+}

plugin/src/main/java/com/alttd/essentia/feature/cuff/CuffListener.java

@@ -1,4 +1,4 @@
-package com.alttd.essentia.listeners;
+package com.alttd.essentia.feature.cuff;
 
 import com.alttd.essentia.EssentiaPlugin;
 import com.alttd.essentia.api.user.User;

plugin/src/main/java/com/alttd/essentia/feature/flight/FlightFeature.java

@@ -0,0 +1,31 @@
+package com.alttd.essentia.feature.flight;
+
+import com.alttd.essentia.EssentiaPlugin;
+import com.alttd.essentia.feature.EssentiaFeature;
+
+public class FlightFeature implements EssentiaFeature {
+
+    private final EssentiaPlugin plugin;
+
+    private boolean enabled = false;
+
+    public FlightFeature() {
+        this.plugin = EssentiaPlugin.instance();
+    }
+
+    @Override
+    public String featureName() {
+        return "flight";
+    }
+
+    @Override
+    public void register() {
+        this.enabled = true;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/feature/flight/FlightListener.java

@@ -1,4 +1,4 @@
-package com.alttd.essentia.listeners;
+package com.alttd.essentia.feature.flight;
 
 import com.alttd.essentia.EssentiaPlugin;
 import com.alttd.essentia.api.model.UserSettings;
@@ -8,7 +8,7 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerChangedWorldEvent;
-
+// TODO -- set flight and flying when player logs in!
 public class FlightListener implements Listener {
 
     private final EssentiaPlugin plugin;

plugin/src/main/java/com/alttd/essentia/feature/godmode/GodModeFeature.java

@@ -0,0 +1,45 @@
+package com.alttd.essentia.feature.godmode;
+
+import com.alttd.essentia.EssentiaPlugin;
+import com.alttd.essentia.api.model.UserSettings;
+import com.alttd.essentia.api.user.User;
+import com.alttd.essentia.api.user.UserManager;
+import com.alttd.essentia.feature.EssentiaFeature;
+import org.bukkit.entity.Player;
+
+public class GodModeFeature implements EssentiaFeature {
+
+    private final EssentiaPlugin plugin;
+
+    private boolean enabled = false;
+
+    public GodModeFeature() {
+        this.plugin = EssentiaPlugin.instance();
+    }
+
+    @Override
+    public String featureName() {
+        return "GodMode";
+    }
+
+    @Override
+    public void register() {
+        this.enabled = true;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    protected boolean isGodModeEnabled(Player player) {
+        UserManager userManager = plugin.userManager();
+        User user = userManager.getUser(player);
+        if (user == null)
+            return false;
+
+        UserSettings userSettings = user.getUserSettings();
+        return userSettings.godMode();
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/feature/godmode/GodModeListener.java

@@ -0,0 +1,114 @@
+package com.alttd.essentia.feature.godmode;
+
+import com.destroystokyo.paper.event.entity.PhantomPreSpawnEvent;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.*;
+
+public class GodModeListener implements Listener {
+
+    private GodModeFeature godModeFeature;
+    public GodModeListener(GodModeFeature godModeFeature) {
+        this.godModeFeature = godModeFeature;
+    }
+
+    @EventHandler
+    public void onFoodLevelChange(FoodLevelChangeEvent event) {
+        if (!(event.getEntity() instanceof Player player))
+            return;
+
+        if (!isGodModeEnabled(player))
+            return;
+
+        event.setCancelled(true);
+    }
+
+
+    @EventHandler
+    public void onPhantomPreSpawn(PhantomPreSpawnEvent event) {
+        if (!(event.getSpawningEntity() instanceof Player player))
+            return;
+
+        if (!isGodModeEnabled(player))
+            return;
+
+        event.setCancelled(true);
+        event.setShouldAbortSpawn(true);
+    }
+
+    @EventHandler
+    public void onEntityTargetLivingEntity(EntityTargetLivingEntityEvent event) {
+        if (!(event.getEntity() instanceof Player player))
+            return;
+
+        if (!isGodModeEnabled(player))
+            return;
+
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onEntityDamageByEntityEvent(EntityDamageByEntityEvent event) {
+        if (!(event.getEntity() instanceof Player player))
+            return;
+
+        if (!isGodModeEnabled(player))
+            return;
+
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onPotionSplashEvent(PotionSplashEvent event) {
+        for (LivingEntity entity : event.getAffectedEntities()) {
+            if (!(entity instanceof Player player))
+                continue;
+
+            if (!isGodModeEnabled(player))
+                return;
+
+            event.setIntensity(player, 0f);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onEntityCombustByEntityEvent(EntityCombustByEntityEvent event) {
+        if (!(event.getEntity() instanceof Player player))
+            return;
+
+        if (!isGodModeEnabled(player))
+            return;
+
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
+    public void onEntityCombust(final EntityCombustEvent event) {
+        if (!(event.getEntity() instanceof Player player))
+            return;
+
+        if (!isGodModeEnabled(player))
+            return;
+
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
+    public void onEntityDamage(final EntityDamageEvent event) {
+        if (!(event.getEntity() instanceof Player player))
+            return;
+
+        if (!isGodModeEnabled(player))
+            return;
+
+        event.setCancelled(true);
+    }
+
+    private boolean isGodModeEnabled(Player player) {
+        return godModeFeature.isGodModeEnabled(player);
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/feature/randomteleport/BiomeValidator.java

@@ -0,0 +1,29 @@
+package com.alttd.essentia.feature.randomteleport;
+
+import com.alttd.essentia.api.model.randomteleport.LocationValidator;
+import org.bukkit.Location;
+import org.bukkit.block.Biome;
+import org.bukkit.block.Block;
+
+import java.util.HashSet;
+import java.util.Set;
+
+// TODO - load biomes from config
+public class BiomeValidator implements LocationValidator {
+
+    private final boolean whitelist;
+    private final Set<Biome> biomes;
+
+    public BiomeValidator() {
+        this.biomes = new HashSet<>();
+        this.whitelist = false;
+        this.biomes.add(Biome.OCEAN);
+    }
+
+    @Override
+    public boolean validate(Location location) {
+        Block block = location.getBlock();
+        return biomes.contains(block.getBiome()) == whitelist;
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/feature/randomteleport/BlockValidator.java

@@ -0,0 +1,28 @@
+package com.alttd.essentia.feature.randomteleport;
+
+import com.alttd.essentia.api.model.randomteleport.LocationValidator;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+
+import java.util.HashSet;
+import java.util.Set;
+
+// TODO - load block list from config
+public class BlockValidator implements LocationValidator {
+
+    private final boolean whitelist;
+    private final Set<Material> materials;
+
+    public BlockValidator() {
+        materials = new HashSet<>();
+        this.whitelist = false;
+    }
+
+    @Override
+    public boolean validate(Location location) {
+        Block block = location.getBlock();
+        return materials.contains(block.getType()) == whitelist;
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/feature/randomteleport/ProtectionValidator.java

@@ -0,0 +1,14 @@
+package com.alttd.essentia.feature.randomteleport;
+
+import com.alttd.essentia.api.model.randomteleport.LocationValidator;
+import org.bukkit.Location;
+
+// TODO - claim hooks for GP. LandClaims should hook into the plugin and add the validator.
+public class ProtectionValidator implements LocationValidator {
+
+    @Override
+    public boolean validate(Location location) {
+        return false;
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/feature/randomteleport/WorldBorderValidator.java

@@ -0,0 +1,13 @@
+package com.alttd.essentia.feature.randomteleport;
+
+import com.alttd.essentia.api.model.randomteleport.LocationValidator;
+import org.bukkit.Location;
+
+public class WorldBorderValidator implements LocationValidator {
+
+    @Override
+    public boolean validate(Location location) {
+        return location.getWorld().getWorldBorder().isInside(location);
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/feature/savedinventory/SavedInventoryFeature.java

@@ -0,0 +1,4 @@
+package com.alttd.essentia.feature.savedinventory;
+
+public class SavedInventoryFeature {
+}

plugin/src/main/java/com/alttd/essentia/feature/savedinventory/SavedInventoryListener.java

@@ -0,0 +1,27 @@
+package com.alttd.essentia.feature.savedinventory;
+
+import com.alttd.essentia.EssentiaPlugin;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+public class SavedInventoryListener implements Listener {
+
+    private final EssentiaPlugin plugin;
+
+    public SavedInventoryListener() {
+        this.plugin = EssentiaPlugin.instance();
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onPlayerDeath(PlayerDeathEvent event) {
+        // TODO -- add config value to save on death
+    }
+
+    @EventHandler()
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        // TODO -- add config value to save on leave
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/feature/savedinventory/gui/SavedInventoryPreviewGUI.java

@@ -0,0 +1,8 @@
+package com.alttd.essentia.feature.savedinventory.gui;
+
+public class SavedInventoryPreviewGUI {
+
+    // preview saved inventory, also acts as the live preview of another player's inventory/ec
+
+
+}

plugin/src/main/java/com/alttd/essentia/listeners/GodModeListener.java

@@ -1,67 +0,0 @@
-package com.alttd.essentia.listeners;
-
-import com.alttd.essentia.EssentiaPlugin;
-import com.alttd.essentia.api.model.UserSettings;
-import com.alttd.essentia.api.user.User;
-import com.alttd.essentia.api.user.UserManager;
-import com.destroystokyo.paper.event.entity.PhantomPreSpawnEvent;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.entity.EntityTargetLivingEntityEvent;
-import org.bukkit.event.entity.FoodLevelChangeEvent;
-
-public class GodModeListener implements Listener {
-
-    private final EssentiaPlugin plugin;
-
-    public GodModeListener() {
-        this.plugin = EssentiaPlugin.instance();
-    }
-
-    @EventHandler
-    public void onFoodLevelChange(FoodLevelChangeEvent event) {
-        if (!(event.getEntity() instanceof Player player))
-            return;
-
-        if (!hasGodMode(player))
-            return;
-
-        event.setCancelled(true);
-    }
-
-
-    @EventHandler
-    public void onPhantomPreSpawn(PhantomPreSpawnEvent event) {
-        if (!(event.getSpawningEntity() instanceof Player player))
-            return;
-
-        if (!hasGodMode(player))
-            return;
-
-        event.setCancelled(true);
-        event.setShouldAbortSpawn(true);
-    }
-
-    @EventHandler
-    public void onEntityTargetLivingEntity(EntityTargetLivingEntityEvent event) {
-        if (!(event.getEntity() instanceof Player player))
-            return;
-
-        if (!hasGodMode(player))
-            return;
-
-        event.setCancelled(true);
-    }
-
-    private boolean hasGodMode(Player player) {
-        UserManager userManager = plugin.userManager();
-        User user = userManager.getUser(player);
-        if (user == null)
-            return false;
-
-        UserSettings userSettings = user.getUserSettings();
-        return userSettings.godMode();
-    }
-
-}

plugin/src/main/java/com/alttd/essentia/model/PlayerInventory.java

@@ -1,4 +0,0 @@
-package com.alttd.essentia.model;
-
-public record PlayerInventory() {
-}

plugin/src/main/java/com/alttd/essentia/model/SavedInventory.java

@@ -0,0 +1,8 @@
+package com.alttd.essentia.model;
+
+import org.bukkit.Location;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.UUID;
+
+public record SavedInventory(int id, ItemStack[] storageContents, ItemStack[] armorContents, UUID ownerUUID, String saveReason, Location location, long date) { }

plugin/src/main/java/com/alttd/essentia/model/annotations/Depends.java

@@ -0,0 +1,12 @@
+package com.alttd.essentia.model.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Depends {
+    String value();
+}

plugin/src/main/java/com/alttd/essentia/request/EssentiaRequest.java

@@ -12,10 +12,10 @@ import org.bukkit.entity.Player;
 
 public abstract class EssentiaRequest implements Request {
 
-    private final EssentiaPlugin plugin;
+    protected final EssentiaPlugin plugin;
     @Getter private final Player requester;
     @Getter private final Player target;
-    private final RequestTimeout timeoutTask;
+    @Getter private final RequestTimeout timeoutTask;
 
     TagResolver placeholders;
 

plugin/src/main/java/com/alttd/essentia/request/RandomTeleportRequest.java

@@ -0,0 +1,168 @@
+package com.alttd.essentia.request;
+
+import com.alttd.essentia.EssentiaPlugin;
+import com.alttd.essentia.api.model.randomteleport.LocationValidator;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.MultimapBuilder;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.CompletableFuture;
+
+public class RandomTeleportRequest extends EssentiaRequest {
+
+    private static final List<int[]> CHUNK_POS = new ArrayList<>();
+    private final Multimap<Integer, Integer> checked = MultimapBuilder.hashKeys().hashSetValues().build();
+
+    private final Random random;
+    private final Location center; // todo - config
+    private final int minRadius; // todo - config
+    private final int maxRadius; // todo - config
+    private final int maxTries = 100; // TODO - config
+
+    private int checks;
+    CompletableFuture<Location> future;
+
+    static {
+        for (int x = 0; x < 16; x++) {
+            for (int z = 0; z < 16; z++) {
+                CHUNK_POS.add(new int[]{x, z});
+            }
+        }
+    }
+
+    public RandomTeleportRequest(EssentiaPlugin plugin, Player requester, Player target) {
+        super(plugin, requester, target);
+        this.random = new Random();
+        this.center = Bukkit.getWorlds().getFirst().getSpawnLocation(); // todo - config and sanity check for worlds
+        this.minRadius = 50;
+        this.maxRadius = 20000;
+
+        this.timeoutTask().cancel();
+        this.teleport();
+    }
+
+    /**
+     * Start searching for a safe random location within the world
+     *
+     * @return A CompletableFuture for when the searching is finished.
+     */
+    public CompletableFuture<Location> startSearch() {
+        future = new CompletableFuture<>();
+        target().sendRichMessage("Running search task");
+        plugin.getServer().getScheduler().runTask(plugin, () -> searchRandomLocation(future));
+        return future;
+    }
+
+    // needs to be a task
+    private void searchRandomLocation(CompletableFuture<Location> future) {
+        if (future.isCancelled() || future.isDone() || future.isCompletedExceptionally()) {
+            return;
+        }
+        Location randomLoc = center.clone();
+        int minChunk = minRadius >> 4;
+        int maxChunk = maxRadius >> 4;
+        int randChunkX;
+        int randChunkZ;
+
+        do {
+            checks++;
+            if (checks >= maxTries) {
+                future.completeExceptionally(new Exception("Could not find random location within %s tries".formatted(maxTries + "")));
+                return;
+            }
+            randChunkX = (random.nextBoolean() ? 1 : -1) * random.nextInt(maxChunk + 1);
+            randChunkZ = (random.nextBoolean() ? 1 : -1) * random.nextInt(maxChunk + 1);
+            target().sendRichMessage("randChunkX: " + randChunkX + ", randChunkZ: " + randChunkZ);
+        } while (!checked.put(randChunkX, randChunkZ)
+                || !inRadius(Math.abs(randChunkX), Math.abs(randChunkZ), minChunk, maxChunk)
+                /*|| randomLoc.getWorld().isChunkGenerated(randChunkX, randChunkZ)*/);
+
+
+        randomLoc.setX(((center.getBlockX() >> 4) + randChunkX) * 16);
+        randomLoc.setZ(((center.getBlockZ() >> 4) + randChunkZ) * 16);
+        randomLoc.getWorld().getChunkAtAsync(randomLoc).thenApply(chunk -> {
+            if (chunk == null) {
+                searchRandomLocation(future);
+                return false;
+            }
+            chunk.addPluginChunkTicket(plugin);
+            try {
+                int indexOffset = random.nextInt(CHUNK_POS.size());
+                Location foundLoc = null;
+                for (int i = 0; i < CHUNK_POS.size(); i++) {
+                    int index = (i + indexOffset) % CHUNK_POS.size();
+                    boolean validated = true;
+                    Location loc = randomLoc.clone().add(CHUNK_POS.get(index)[0], 0, CHUNK_POS.get(index)[1]);
+
+                    if (!inRadius(loc)) {
+                        continue;
+                    }
+
+                    for (LocationValidator validator : plugin.locationValidators()) {
+                        if (!validator.validate(loc)) {
+                            validated = false;
+                            break;
+                        }
+                    }
+                    if (validated) {
+                        foundLoc = loc;
+                        break;
+                    }
+                }
+
+                if (foundLoc != null) {
+                    // all checks are for the top block, put we want a location above that so add 1 to y
+                    future.complete(foundLoc.add(0, 1, 0));
+                    return true;
+                }
+                plugin.getServer().getScheduler().runTaskLater(plugin, () -> searchRandomLocation(future), 1);
+                return false;
+            } finally {
+                chunk.removePluginChunkTicket(plugin);
+            }
+        }).exceptionally(future::completeExceptionally);
+    }
+
+    private boolean inRadius(Location location) {
+        int diffX = Math.abs(location.getBlockX() - center.getBlockX());
+        int diffZ = Math.abs(location.getBlockZ() - center.getBlockZ());
+        return inRadius(diffX, diffZ, minRadius, maxRadius);
+    }
+
+    private boolean inRadius(int diffX, int diffZ, int minRadius, int maxRadius) {
+        return diffX >= minRadius && diffX <= maxRadius && diffZ <= maxRadius
+                || diffZ >= minRadius && diffZ <= maxRadius && diffX <= maxRadius;
+    }
+
+    @Override
+    protected void teleport() {
+        startSearch().thenApply(randomLocation -> {
+            randomLocation.setX(randomLocation.getBlockX() + 0.5);
+            randomLocation.setY(randomLocation.getY() + 0.5);
+            randomLocation.setZ(randomLocation.getBlockZ() + 0.5);
+            target().teleportAsync(randomLocation)
+                    .whenComplete((success, exception) -> {
+                        target().sendMessage("You have been teleported to a random location."); // todo -- config
+                    });
+            return true;
+        });
+        if (!target().isOnline() || !requester().isOnline()) {
+            cancel();
+            return;
+        }
+    }
+
+    @Override
+    public void cancel() {
+        try {
+            timeoutTask().cancel();
+        } catch (IllegalStateException ignore) {
+        }
+    }
+
+}

plugin/src/main/java/com/alttd/essentia/util/Pair.java

@@ -0,0 +1,5 @@
+package com.alttd.essentia.util;
+
+public record Pair<X, Y>(X x, Y y) {
+
+}

plugin/src/main/java/com/alttd/essentia/util/Timer.java

@@ -0,0 +1,17 @@
+package com.alttd.essentia.util;
+
+import com.alttd.essentia.EssentiaPlugin;
+
+public class Timer {
+
+    public Timer(String id, Runnable runnable) {
+        long startTime = System.currentTimeMillis();
+
+        runnable.run();
+
+        long duration = System.currentTimeMillis() - startTime;
+
+        EssentiaPlugin.instance().getLogger().info("Loading " + id + " took " + duration + "ms");
+    }
+
+}

plugin/src/main/resources/plugin.yml

@@ -2,6 +2,7 @@ name: Essentia
 version: ${version}
 main: com.alttd.essentia.EssentiaPlugin
 description: Altitude essentials ;)
+load: POSTWORLD
 authors:
   - destro174
 api-version: "1.21"