Fix the damn buildscripts I keep on missing

- [FEAT] Improved config system to fix old loading bugs and support JSON
- [FEAT] LuckPerms support for commands

.gitattributes

@@ -2,7 +2,7 @@
 *.bat text eol=crlf
 *.patch text eol=lf
 *.java text eol=lf
-*.gradle text eol=crlf
+*.gradle text eol=lf
 *.png binary
 *.gif binary
 *.exe binary

.gitignore

@@ -23,3 +23,7 @@ run
 
 artifacts
 src/test/**
+dev
+upstream
+rejects
+workspace

.idea/.gitignore

@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml

.idea/discord.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="DiscordProjectSettings">
-    <option name="show" value="ASK" />
-    <option name="description" value="" />
-  </component>
-</project>

.idea/misc.xml

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="EntryPointsManager">
-    <list size="4">
-      <item index="0" class="java.lang.String" itemvalue="net.minecraftforge.fml.common.Mod" />
-      <item index="1" class="java.lang.String" itemvalue="net.minecraftforge.fml.common.Mod.EventHandler" />
-      <item index="2" class="java.lang.String" itemvalue="net.minecraftforge.fml.common.eventhandler.SubscribeEvent" />
-      <item index="3" class="java.lang.String" itemvalue="net.minecraftforge.eventbus.api.SubscribeEvent" />
-    </list>
-  </component>
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="FrameworkDetectionExcludesConfiguration">
-    <file type="web" url="file://$PROJECT_DIR$" />
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="corretto-21" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>

.jenkins/Jenkinsfile.snapshot

@@ -1,62 +0,0 @@
-def projectName = "CraterLib";
-def projectIcon = "https://cdn.modrinth.com/data/Nn8Wasaq/a172c634683a11a2e9ae593e56eba7885743bb44.png";
-
-pipeline {
-    agent {
-        label "master"
-    }
-    tools {
-        jdk "JAVA17"
-    }
-
-    stages {
-        stage("Notify Discord") {
-            steps {
-                discordSend webhookURL: env.SSS_WEBHOOK,
-                        title: "Deploy Started: ${projectName} Port Deploy #${BUILD_NUMBER}",
-                        link: env.BUILD_URL,
-                        result: 'SUCCESS',
-                        description: "Build: [${BUILD_NUMBER}](${env.BUILD_URL})"
-            }
-        }
-
-        stage("Prepare") {
-            steps {
-                sh "chmod +x ./gradlew"
-                sh "./gradlew clean"
-            }
-        }
-
-        stage("Build") {
-            steps {
-                sh "./gradlew build"
-            }
-        }
-
-        stage("Publish to Maven") {
-            steps {
-                catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
-                    sh "./gradlew publish"
-                }
-            }
-        }
-    }
-
-    post {
-        always {
-            sh "./gradlew --stop"
-            archiveArtifacts artifacts: 'artifacts/*.jar'
-
-            fddsnapshotter apiKey: env.PLATFORM_KEY,
-                projectSlug: "craterlib",
-                projectName: "${projectName}",
-                projectIcon: "${projectIcon}",
-                modLoaders: "forge|neoforge|fabric|quilt",
-                minecraftVersions: "1.20.6",
-                failWebhook: env.SSS_WEBHOOK,
-                publishWebhooks: "${env.SSS_WEBHOOK}|${env.FDD_WH}"
-
-            deleteDir()
-        }
-    }
-}

1.18.2/.gitattributes

@@ -0,0 +1,15 @@
+* text eol=lf
+*.bat text eol=crlf
+*.patch text eol=lf
+*.java text eol=lf
+*.gradle text eol=crlf
+*.png binary
+*.gif binary
+*.exe binary
+*.dll binary
+*.jar binary
+*.lzma binary
+*.zip binary
+*.pyd binary
+*.cfg text eol=lf
+*.jks binary

1.18.2/.gitignore

@@ -0,0 +1,29 @@
+# eclipse
+bin
+*.launch
+.settings
+.metadata
+.classpath
+.project
+
+# idea
+out
+*.ipr
+*.iws
+*.iml
+.idea
+
+# gradle
+build
+.gradle
+
+# other
+eclipse
+run
+
+artifacts
+src/test/**
+
+workspace
+upstream
+rejects

1.18.2/.jenkins/Jenkinsfile.deploy

@@ -0,0 +1,64 @@
+def majorMc = "1.18.2";
+def JDK = "17"
+
+pipeline {
+    agent {
+        docker {
+            image "registry.firstdark.dev/java${JDK}:latest"
+            alwaysPull true
+            args '-v gradle-cache:/home/gradle/.gradle'
+        }
+    }
+
+    environment {
+        GRADLE_USER_HOME = '/home/gradle/.gradle'
+    }
+
+    stages {
+        stage("Notify Discord") {
+            steps {
+                discordSend webhookURL: env.FDD_WH_ADMIN,
+                        title: "Deploy Started: CraterLib ${majorMc} Deploy #${BUILD_NUMBER}",
+                        link: env.BUILD_URL,
+                        result: 'SUCCESS',
+                        description: "Build: [${BUILD_NUMBER}](${env.BUILD_URL})"
+            }
+        }
+        stage("Prepare") {
+            steps {
+                dir("${WORKSPACE}/${majorMc}") {
+                    sh "chmod +x ./gradlew"
+                    sh "./gradlew clean"
+                }
+            }
+        }
+        stage("Publish to Modrinth/Curseforge") {
+            steps {
+                dir("${WORKSPACE}/${majorMc}") {
+                    sh "./gradlew publishMod -Prelease=true"
+                }
+            }
+        }
+        stage("Publish to Maven") {
+            steps {
+                dir("${WORKSPACE}/${majorMc}") {
+                    sh "./gradlew publish -Prelease=true"
+                }
+            }
+        }
+    }
+    post {
+        always {
+            dir("${WORKSPACE}/${majorMc}") {
+                sh "./gradlew --stop"
+                deleteDir()
+            }
+
+            discordSend webhookURL: env.FDD_WH_ADMIN,
+                    title: "CraterLib Port Deploy #${BUILD_NUMBER}",
+                    link: env.BUILD_URL,
+                    result: currentBuild.currentResult,
+                    description: "Build: [${BUILD_NUMBER}](${env.BUILD_URL})\nStatus: ${currentBuild.currentResult}"
+        }
+    }
+}

1.18.2/.jenkins/Jenkinsfile.snapshot

@@ -0,0 +1,80 @@
+def projectName = "CraterLib";
+def projectIcon = "https://cdn.modrinth.com/data/Nn8Wasaq/a172c634683a11a2e9ae593e56eba7885743bb44.png";
+def JDK = "17";
+def majorMc = "1.18.2";
+def modLoaders = "forge|fabric|quilt";
+def supportedMc = "1.18.2";
+def reltype = "snapshot";
+
+pipeline {
+    agent {
+        docker {
+            image "registry.firstdark.dev/java${JDK}:latest"
+            alwaysPull true
+            args '-v gradle-cache:/home/gradle/.gradle'
+        }
+    }
+
+    environment {
+        GRADLE_USER_HOME = '/home/gradle/.gradle'
+    }
+
+    stages {
+        stage('Checkout') {
+            steps {
+                scmSkip(deleteBuild: false, skipPattern:'.*\\[ci skip\\].*')
+            }
+        }
+
+        stage("Notify Discord") {
+            steps {
+                discordSend webhookURL: env.SSS_WEBHOOK,
+                        title: "Deploy Started: ${projectName} ${majorMc} Deploy #${BUILD_NUMBER}",
+                        link: env.BUILD_URL,
+                        result: 'SUCCESS',
+                        description: "Build: [${BUILD_NUMBER}](${env.BUILD_URL})"
+            }
+        }
+
+        stage("Prepare") {
+            steps {
+                dir("${WORKSPACE}/${majorMc}") {
+                    sh "chmod +x ./gradlew"
+                    sh "./gradlew build -PreleaseType=${reltype}"
+                }
+            }
+        }
+
+        stage("Publish to Maven") {
+            steps {
+                dir ("${WORKSPACE}/${majorMc}") {
+                    catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                        sh "./gradlew publish -PreleaseType=${reltype}"
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        always {
+            dir("${WORKSPACE}/${majorMc}") {
+                sh "./gradlew --stop"
+                archiveArtifacts artifacts: 'artifacts/*.jar'
+
+                fddsnapshotter apiKey: env.PLATFORM_KEY,
+                    projectSlug: "craterlib",
+                    projectName: "${projectName}",
+                    projectIcon: "${projectIcon}",
+                    modLoaders: "${modLoaders}",
+                    minecraftVersions: "${supportedMc}",
+                    type: "snapshot",
+                    dependsOn: "",
+                    failWebhook: env.SSS_WEBHOOK,
+                    publishWebhooks: "${env.SSS_WEBHOOK}|${env.FDD_WH}"
+
+                deleteDir()
+            }
+        }
+    }
+}

1.18.2/Common/build.gradle

@@ -1,6 +1,9 @@
 archivesBaseName = "${mod_name.replace(" ", "")}-Common-${minecraft_version}"
 
 dependencies {
+    stupidRemapArch("dev.ftb.mods:ftb-ranks:${ftb_ranks}")
+
+    stupidRemapArch("me.shedaniel.cloth:cloth-config:${cloth_config}")
 
 }
 

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/commands/CraterCommand.java

@@ -0,0 +1,163 @@
+package com.hypherionmc.craterlib.api.commands;
+
+import com.hypherionmc.craterlib.CraterConstants;
+import com.hypherionmc.craterlib.compat.LuckPermsCompat;
+import com.hypherionmc.craterlib.core.platform.LoaderType;
+import com.hypherionmc.craterlib.core.platform.ModloaderEnvironment;
+import com.hypherionmc.craterlib.nojang.authlib.BridgedGameProfile;
+import com.hypherionmc.craterlib.nojang.commands.BridgedCommandSourceStack;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import com.hypherionmc.craterlib.utils.TriConsumer;
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.arguments.BoolArgumentType;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import net.minecraft.commands.arguments.GameProfileArgument;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.player.Player;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.List;
+import java.util.function.Consumer;
+
+public class CraterCommand {
+
+    private final LiteralArgumentBuilder<CommandSourceStack> mojangCommand;
+    private int permLevel = 4;
+    private String luckPermNode = "";
+
+    CraterCommand(LiteralArgumentBuilder<CommandSourceStack> cmd) {
+        this.mojangCommand = cmd;
+    }
+
+    public static CraterCommand literal(String commandName) {
+        return new CraterCommand(Commands.literal(commandName));
+    }
+
+    public CraterCommand requiresPermission(int perm) {
+        this.permLevel = perm;
+        this.mojangCommand.requires(this::checkPermission);
+        return this;
+    }
+
+    public CraterCommand withNode(String key) {
+        this.luckPermNode = key;
+        return this;
+    }
+
+    public CraterCommand then(CraterCommand child) {
+        this.mojangCommand.then(child.mojangCommand);
+        return this;
+    }
+
+    public CraterCommand withGameProfilesArgument(String key, CommandExecutorWithArgs<List<BridgedGameProfile>> executor) {
+        this.mojangCommand.then(Commands.argument(key, GameProfileArgument.gameProfile())
+                .executes(context -> executor.run(
+                        BridgedPlayer.of(context.getSource().getPlayerOrException()),
+                        GameProfileArgument.getGameProfiles(context, key).stream().map(BridgedGameProfile::of).toList(),
+                        BridgedCommandSourceStack.of(context.getSource()))
+                ));
+        return this;
+    }
+
+    public CraterCommand withBoolArgument(String key, CommandExecutorWithArgs<Boolean> executor) {
+        this.mojangCommand.then(Commands.argument(key, BoolArgumentType.bool())
+                .executes(context -> executor.run(
+                        BridgedPlayer.of(context.getSource().getPlayerOrException()),
+                        BoolArgumentType.getBool(context, key),
+                        BridgedCommandSourceStack.of(context.getSource())
+                )));
+        return this;
+    }
+
+    public CraterCommand withWordArgument(String key, CommandExecutorWithArgs<String> executor) {
+        this.mojangCommand.then(Commands.argument(key, StringArgumentType.word())
+                .executes(context -> executor.run(
+                        BridgedPlayer.of(context.getSource().getPlayerOrException()),
+                        StringArgumentType.getString(context, key),
+                        BridgedCommandSourceStack.of(context.getSource())
+                )));
+        return this;
+    }
+
+    public CraterCommand withStringArgument(String key, CommandExecutorWithArgs<String> executor) {
+        this.mojangCommand.then(Commands.argument(key, StringArgumentType.string())
+                .executes(context -> executor.run(
+                        BridgedPlayer.of(context.getSource().getPlayerOrException()),
+                        StringArgumentType.getString(context, key),
+                        BridgedCommandSourceStack.of(context.getSource())
+                )));
+        return this;
+    }
+
+    public CraterCommand withPhraseArgument(String key, CommandExecutorWithArgs<String> executor) {
+        this.mojangCommand.then(Commands.argument(key, StringArgumentType.greedyString())
+                .executes(context -> executor.run(
+                        BridgedPlayer.of(context.getSource().getPlayerOrException()),
+                        StringArgumentType.getString(context, key),
+                        BridgedCommandSourceStack.of(context.getSource())
+                )));
+        return this;
+    }
+
+    public CraterCommand withIntegerArgument(String key, CommandExecutorWithArgs<Integer> executor) {
+        this.mojangCommand.then(Commands.argument(key, IntegerArgumentType.integer())
+                .executes(context -> executor.run(
+                        BridgedPlayer.of(context.getSource().getPlayerOrException()),
+                        IntegerArgumentType.getInteger(context, key),
+                        BridgedCommandSourceStack.of(context.getSource())
+                )));
+        return this;
+    }
+
+    public CraterCommand execute(SingleCommandExecutor<BridgedCommandSourceStack> executor) {
+        this.mojangCommand.executes(context -> executor.run(BridgedCommandSourceStack.of(context.getSource())));
+        return this;
+    }
+
+    @Deprecated(forRemoval = true)
+    public CraterCommand executes(Consumer<BridgedCommandSourceStack> ctx) {
+        return this.execute(stack -> {
+            ctx.accept(stack);
+            return 1;
+        });
+    }
+
+    @Deprecated(forRemoval = true)
+    public CraterCommand withGameProfileArgument(String key, TriConsumer<BridgedPlayer, List<BridgedGameProfile>, BridgedCommandSourceStack> executor) {
+        return this.withGameProfilesArgument(key, (player, argument, stack) -> {
+            executor.accept(player, argument, stack);
+            return 1;
+        });
+    }
+
+    @ApiStatus.Internal
+    public void register(CommandDispatcher<CommandSourceStack> stack) {
+        stack.register(this.mojangCommand);
+    }
+
+    private boolean checkPermission(CommandSourceStack stack) {
+        try {
+        if (!ModloaderEnvironment.INSTANCE.isModLoaded("luckperms") || ModloaderEnvironment.INSTANCE.getLoaderType() == LoaderType.PAPER || !(stack.getEntity() instanceof Player) || luckPermNode.isEmpty())
+                return stack.hasPermission(this.permLevel);
+
+        } catch (Exception e) {
+            CraterConstants.LOG.error("Failed to check luckperms permissions", e);
+            return stack.hasPermission(this.permLevel);
+        }
+        return LuckPermsCompat.INSTANCE.hasPermission((ServerPlayer) stack.getEntity(), this.luckPermNode) || stack.hasPermission(this.permLevel);
+    }
+
+    @FunctionalInterface
+    public interface CommandExecutorWithArgs<S> {
+        int run(BridgedPlayer player, S argument, BridgedCommandSourceStack stack);
+    }
+
+    @FunctionalInterface
+    public interface SingleCommandExecutor<S> {
+        int run(S stack);
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/compat/FTBRankEvents.java

@@ -0,0 +1,56 @@
+// @excludeplugin
+package com.hypherionmc.craterlib.api.events.compat;
+
+import com.hypherionmc.craterlib.compat.ftbranks.BridgedRank;
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.authlib.BridgedGameProfile;
+import com.mojang.authlib.GameProfile;
+import dev.ftb.mods.ftbranks.api.Rank;
+import lombok.Getter;
+
+public class FTBRankEvents {
+
+    @Getter
+    public static class RankAddedEvent extends CraterEvent {
+        private final BridgedGameProfile gameProfile;
+        private final BridgedRank rank;
+
+        private RankAddedEvent(BridgedGameProfile gameProfile, BridgedRank rank) {
+            this.gameProfile = gameProfile;
+            this.rank = rank;
+        }
+
+        public static RankAddedEvent of(GameProfile profile, Rank rank) {
+            return new RankAddedEvent(BridgedGameProfile.of(profile), BridgedRank.of(rank));
+        }
+    }
+
+    @Getter
+    public static class RankRemovedEvent extends CraterEvent {
+        private final BridgedGameProfile gameProfile;
+        private final BridgedRank rank;
+
+        private RankRemovedEvent(BridgedGameProfile gameProfile, BridgedRank rank) {
+            this.gameProfile = gameProfile;
+            this.rank = rank;
+        }
+
+        public static RankRemovedEvent of(GameProfile profile, Rank rank) {
+            return new RankRemovedEvent(BridgedGameProfile.of(profile), BridgedRank.of(rank));
+        }
+    }
+
+    @Getter
+    public static class RankDeletedEvent extends CraterEvent {
+        private final BridgedRank rank;
+
+        private RankDeletedEvent(BridgedRank rank) {
+            this.rank = rank;
+        }
+
+        public static RankDeletedEvent of(Rank rank) {
+            return new RankDeletedEvent(BridgedRank.of(rank));
+        }
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/compat/LuckPermsCompatEvents.java

@@ -0,0 +1,35 @@
+package com.hypherionmc.craterlib.api.events.compat;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.authlib.BridgedGameProfile;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.UUID;
+
+public class LuckPermsCompatEvents {
+
+    @RequiredArgsConstructor(staticName = "of")
+    @Getter
+    public static class GroupAddedEvent extends CraterEvent {
+        private final String identifier;
+        private final UUID uuid;
+        private final String username;
+
+        public BridgedGameProfile toProfile() {
+            return BridgedGameProfile.mojang(uuid, username);
+        }
+    }
+
+    @RequiredArgsConstructor(staticName = "of")
+    @Getter
+    public static class GroupRemovedEvent extends CraterEvent {
+        private final String identifier;
+        private final UUID uuid;
+        private final String username;
+
+        public BridgedGameProfile toProfile() {
+            return BridgedGameProfile.mojang(uuid, username);
+        }
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/compat/PlayerBleedOutEvent.java

@@ -0,0 +1,12 @@
+package com.hypherionmc.craterlib.api.events.compat;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(staticName = "of")
+@Getter
+public class PlayerBleedOutEvent extends CraterEvent {
+    private final BridgedPlayer player;
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/compat/PlayerRevivedEvent.java

@@ -0,0 +1,12 @@
+package com.hypherionmc.craterlib.api.events.compat;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(staticName = "of")
+@Getter
+public class PlayerRevivedEvent extends CraterEvent {
+    private final BridgedPlayer player;
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/server/CraterCommandEvent.java

@@ -0,0 +1,58 @@
+package com.hypherionmc.craterlib.api.events.server;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import com.hypherionmc.craterlib.utils.ChatUtils;
+import com.mojang.brigadier.ParseResults;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.context.StringRange;
+import lombok.Getter;
+import lombok.Setter;
+import net.kyori.adventure.text.Component;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.arguments.ComponentArgument;
+import net.minecraft.world.entity.player.Player;
+import org.jetbrains.annotations.Nullable;
+
+@Getter
+public class CraterCommandEvent extends CraterEvent {
+
+    private final ParseResults<CommandSourceStack> parseResults;
+    @Setter private Throwable exception;
+    private final String command;
+
+    private CraterCommandEvent(ParseResults<CommandSourceStack> parseResults, String command) {
+        this.parseResults = parseResults;
+        this.command = command;
+    }
+
+    public static CraterCommandEvent of(ParseResults<CommandSourceStack> stack, String command) {
+        return new CraterCommandEvent(stack, command);
+    }
+
+    public String getCommandString() {
+        return parseResults.getReader().getString();
+    }
+
+    @Nullable
+    public BridgedPlayer getPlayer() {
+        try {
+            Player p = parseResults.getContext().getLastChild().getSource().getPlayerOrException();
+
+            if (p != null)
+                return BridgedPlayer.of(p);
+        } catch (Exception ignored) {}
+
+        return null;
+    }
+
+    public String getTarget() {
+        CommandContext<CommandSourceStack> context = parseResults.getContext().build(parseResults.getReader().getString());
+        StringRange selector_range = parseResults.getContext().getArguments().get("targets").getRange();
+        return context.getInput().substring(selector_range.getStart(), selector_range.getEnd());
+    }
+
+    public Component getMessage() {
+        return ChatUtils.mojangToAdventure(ComponentArgument.getComponent(parseResults.getContext().build(parseResults.getReader().getString()), "message"));
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/server/CraterPlayerEvent.java

@@ -11,18 +11,32 @@ public class CraterPlayerEvent extends CraterEvent {
 
     private final BridgedPlayer player;
 
+    @Getter
     public static class PlayerLoggedIn extends CraterPlayerEvent {
+        private final boolean isFromVanish;
 
         public PlayerLoggedIn(BridgedPlayer player) {
+            this(player, false);
+        }
+
+        public PlayerLoggedIn(BridgedPlayer player, boolean isFromVanish) {
             super(player);
+            this.isFromVanish = isFromVanish;
         }
 
     }
 
+    @Getter
     public static class PlayerLoggedOut extends CraterPlayerEvent {
+        private final boolean isFromVanish;
 
         public PlayerLoggedOut(BridgedPlayer player) {
+            this(player, false);
+        }
+
+        public PlayerLoggedOut(BridgedPlayer player, boolean isFromVanish) {
             super(player);
+            this.isFromVanish = isFromVanish;
         }
 
     }

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/server/CraterRegisterCommandEvent.java

@@ -2,14 +2,17 @@ package com.hypherionmc.craterlib.api.events.server;
 
 import com.hypherionmc.craterlib.api.commands.CraterCommand;
 import com.hypherionmc.craterlib.core.event.CraterEvent;
-import com.hypherionmc.craterlib.nojang.commands.CommandsRegistry;
-import lombok.NoArgsConstructor;
+import com.mojang.brigadier.CommandDispatcher;
+import lombok.AllArgsConstructor;
+import net.minecraft.commands.CommandSourceStack;
 
-@NoArgsConstructor
+@AllArgsConstructor
 public class CraterRegisterCommandEvent extends CraterEvent {
 
+    private final CommandDispatcher<CommandSourceStack> stack;
+
     public void registerCommand(CraterCommand cmd) {
-        CommandsRegistry.INSTANCE.registerCommand(cmd);
+        cmd.register(stack);
     }
 
 }

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/server/ServerStatusEvent.java

@@ -0,0 +1,35 @@
+package com.hypherionmc.craterlib.api.events.server;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.network.protocol.status.WrappedServerStatus;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Optional;
+
+public class ServerStatusEvent {
+
+    @RequiredArgsConstructor
+    @Getter
+    @Setter
+    public static class StatusRequestEvent extends CraterEvent {
+
+        private final Component status;
+        @Nullable
+        private Component newStatus = null;
+
+    }
+
+    @RequiredArgsConstructor
+    @Getter
+    @Setter
+    public static class FaviconRequestEvent extends CraterEvent {
+
+        private final Optional<WrappedServerStatus.WrappedFavicon> favicon;
+        private Optional<WrappedServerStatus.WrappedFavicon> newIcon = Optional.empty();
+
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/server/WhitelistChangedEvent.java

@@ -0,0 +1,26 @@
+package com.hypherionmc.craterlib.api.events.server;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.authlib.BridgedGameProfile;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+public class WhitelistChangedEvent {
+
+    @RequiredArgsConstructor
+    @Getter
+    public static final class EntryAdded extends CraterEvent {
+
+        private final BridgedGameProfile profile;
+
+    }
+
+    @RequiredArgsConstructor
+    @Getter
+    public static final class EntryRemoved extends CraterEvent {
+
+        private final BridgedGameProfile profile;
+
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/gui/config/ClothConfigScreenBuilder.java

@@ -0,0 +1,411 @@
+package com.hypherionmc.craterlib.client.gui.config;
+
+import com.hypherionmc.craterlib.CraterConstants;
+import com.hypherionmc.craterlib.client.gui.config.widgets.ClothConfigButtonEntry;
+import com.hypherionmc.craterlib.core.config.AbstractConfig;
+import com.hypherionmc.craterlib.core.config.annotations.HideFromScreen;
+import com.hypherionmc.craterlib.core.config.annotations.SubConfig;
+import com.hypherionmc.craterlib.core.config.annotations.Tooltip;
+import me.hypherionmc.moonconfig.core.conversion.SpecComment;
+import me.shedaniel.clothconfig2.api.ConfigBuilder;
+import me.shedaniel.clothconfig2.api.ConfigCategory;
+import me.shedaniel.clothconfig2.api.ConfigEntryBuilder;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.components.toasts.SystemToast;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TextComponent;
+import net.minecraft.network.chat.TranslatableComponent;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author HypherionSA
+ * A Helper Class to convert {@link AbstractConfig}s into Cloth Config Screens
+ */
+@SuppressWarnings({"rawtypes", "unchecked"})
+@ApiStatus.Internal
+public class ClothConfigScreenBuilder {
+
+    /**
+     * Build a new Cloth Config screen, from an {@link AbstractConfig}
+     *
+     * @param config The {@link AbstractConfig} the config screen is for
+     * @param parent The parent {@link Screen} this screen will return to when closed
+     * @return A fully usable Cloth Config screen
+     */
+    public static Screen buildConfigScreen(AbstractConfig config, @Nullable Screen parent) {
+        ConfigBuilder builder = ConfigBuilder.create()
+                .setParentScreen(parent)
+                .setTitle(getTranslationKey(config, config, null));
+
+        readConfigFields(config, config, builder);
+
+        builder.setSavingRunnable(() -> safeSaveConfig(config));
+        return builder.build();
+    }
+
+    /**
+     * Build a new sub-screen for config entries marked with {@link SubConfig}
+     *
+     * @param config The {@link AbstractConfig} the config screen is for
+     * @param clazz The object or class that the screen is being built for
+     * @param parent The parent {@link Screen} this screen will return to when closed
+     * @return A fully usable Cloth Config screen
+     */
+    private static Screen buildSubScreen(AbstractConfig config, Object clazz, @Nullable Screen parent) {
+        ConfigBuilder builder = ConfigBuilder.create()
+                .setParentScreen(parent)
+                .setTitle(getTranslationKey(config, clazz, null));
+
+        readConfigFields(config, clazz, builder);
+
+        builder.setSavingRunnable(() -> safeSaveConfig(config));
+        return builder.build();
+    }
+
+    /**
+     * Build a new screen, that allows editing lists of complex objects, like a list of Classes
+     *
+     * @param config The {@link AbstractConfig} the config screen is for
+     * @param list The list of objects this screen will be responsible for
+     * @param field The field this list belongs to in the main config
+     * @param invoker The object used to invoke the field, when setting the new value
+     * @param parent The parent {@link Screen} this screen will return to when closed
+     * @param edited Was this list edited
+     * @return A fully usable Cloth Config screen
+     */
+    private static Screen buildListScreen(AbstractConfig config, List list, Field field, Object invoker, @Nullable Screen parent, boolean edited) {
+        ConfigBuilder builder = ConfigBuilder.create()
+                .setParentScreen(parent)
+                .setTitle(getTranslationKey(config, invoker, field.getName()));
+
+        ConfigCategory category = builder.getOrCreateCategory(new TextComponent("Entries"));
+
+        // Handle Existing items in the list
+        for (int i = 0; i < list.size(); i++) {
+            Object item = list.get(i);
+
+            int finalI = i;
+            // Add a button to open the edit screen, as well as a delete button
+            category.addEntry(
+                    new ClothConfigButtonEntry(
+                            new TranslatableComponent("cl.buttons.entry", (i + 1)),
+                            new TranslatableComponent("cl.buttons.edit"),
+                            button -> Minecraft.getInstance().setScreen(
+                                    buildSubScreen(config, item, builder.build())
+                            ),
+                            button -> {
+                                list.remove(finalI);
+                                saveFieldValue(list, field, invoker);
+                                Minecraft.getInstance().setScreen(buildListScreen(config, list, field, invoker, parent, true));
+                            },
+                            edited
+                    )
+            );
+        }
+
+        // Add a button to add new list entries
+        Type listType = field.getGenericType();
+        if (listType instanceof ParameterizedType paramType) {
+            Class<?> elementType = (Class<?>) paramType.getActualTypeArguments()[0];
+
+            category.addEntry(
+                    new ClothConfigButtonEntry(
+                            new TextComponent(""),
+                            new TranslatableComponent("cl.buttons.add_entry"),
+                            button -> {
+                                try {
+                                    Object newItem = elementType.getDeclaredConstructor().newInstance();
+                                    list.add(newItem);
+                                    saveFieldValue(list, field, invoker);
+                                    Minecraft.getInstance().setScreen(buildListScreen(config, list, field, invoker, parent, true));
+                                } catch (Exception e) {
+                                    CraterConstants.LOG.error("Failed to create new list entry", e);
+                                }
+                            }
+                    )
+            );
+        }
+
+        builder.setSavingRunnable(() -> safeSaveConfig(config));
+        return builder.build();
+    }
+
+    /**
+     * A helper method to convert an {@link AbstractConfig} into the corresponding cloth config gui fields
+     *
+     * @param baseConfig The {@link AbstractConfig} to convert
+     * @param config The base class that is being processed
+     * @param builder The {@link ClothConfigScreenBuilder} we are currently working with
+     */
+    private static void readConfigFields(AbstractConfig baseConfig, Object config, ConfigBuilder builder) {
+        ConfigEntryBuilder entryBuilder = builder.entryBuilder();
+        ConfigCategory configCategory = builder.getOrCreateCategory(new TextComponent("General"));
+
+        for (Field field : config.getClass().getDeclaredFields()) {
+            try {
+                field.setAccessible(true);
+
+                // We ignore static, transient fields or fields marked with @HideFromScreen
+                final int fieldModifiers = field.getModifiers();
+                if (Modifier.isStatic(fieldModifiers) || Modifier.isTransient(fieldModifiers) || field.isAnnotationPresent(HideFromScreen.class))
+                    continue;
+
+                Object val = field.get(config);
+
+                // Field is marked as sub-config, so we add a button field for it
+                if (field.isAnnotationPresent(SubConfig.class)) {
+                    if (val != null) {
+                        configCategory.addEntry(
+                                new ClothConfigButtonEntry(
+                                        new TranslatableComponent("cl.config." + baseConfig.getClass().getSimpleName().toLowerCase() + "." + field.getName().toLowerCase()),
+                                        new TranslatableComponent("cl.buttons.edit"),
+                                        button -> Minecraft.getInstance().setScreen(
+                                                buildSubScreen(baseConfig, val, builder.build())
+                                        )
+                                )
+                        );
+                        continue;
+                    }
+                }
+
+                // Boolean Values
+                if (val instanceof Boolean bool) {
+                    configCategory.addEntry(entryBuilder.startBooleanToggle(getTranslationKey(baseConfig, config, field.getName()), bool)
+                            .setTooltip(getToolTip(field))
+                            .setSaveConsumer(newValue -> saveFieldValue(newValue, field, config))
+                            .setDefaultValue(bool).build());
+                }
+
+                // Enum Values
+                if (val instanceof Enum<?> enumValue) {
+                    Class<Enum> enumClass = (Class<Enum>)enumValue.getDeclaringClass();
+                    configCategory.addEntry(entryBuilder.startEnumSelector(
+                                    getTranslationKey(baseConfig, config, field.getName()),
+                                    enumClass,
+                                    enumValue)
+                            .setTooltip(getToolTip(field))
+                            .setSaveConsumer(newValue -> saveFieldValue(newValue, field, config))
+                            .setDefaultValue(enumValue)
+                            .build());
+                }
+
+                // Int Values
+                if (val instanceof Integer intt) {
+                    configCategory.addEntry(entryBuilder.startIntField(getTranslationKey(baseConfig, config, field.getName()), intt)
+                            .setTooltip(getToolTip(field))
+                            .setSaveConsumer(newValue -> saveFieldValue(newValue, field, config))
+                            .setDefaultValue(intt).build());
+                }
+
+                // Long Values
+                if (val instanceof Long longt) {
+                    configCategory.addEntry(entryBuilder.startLongField(getTranslationKey(baseConfig, config, field.getName()), longt)
+                            .setTooltip(getToolTip(field))
+                            .setSaveConsumer(newValue -> saveFieldValue(newValue, field, config))
+                            .setDefaultValue(longt).build());
+                }
+
+                // Float Values
+                if (val instanceof Float floatt) {
+                    configCategory.addEntry(entryBuilder.startFloatField(getTranslationKey(baseConfig, config, field.getName()), floatt)
+                            .setTooltip(getToolTip(field))
+                            .setSaveConsumer(newValue -> saveFieldValue(newValue, field, config))
+                            .setDefaultValue(floatt).build());
+                }
+
+                // Double Values
+                if (val instanceof Double doublet) {
+                    configCategory.addEntry(entryBuilder.startDoubleField(getTranslationKey(baseConfig, config, field.getName()), doublet)
+                            .setTooltip(getToolTip(field))
+                            .setSaveConsumer(newValue -> saveFieldValue(newValue, field, config))
+                            .setDefaultValue(doublet).build());
+                }
+
+                // String Values
+                if (val instanceof String string) {
+                    configCategory.addEntry(entryBuilder.startStrField(getTranslationKey(baseConfig, config, field.getName()), string)
+                            .setTooltip(getToolTip(field))
+                            .setSaveConsumer(newValue -> saveFieldValue(newValue, field, config))
+                            .setDefaultValue(string).build());
+                }
+
+                // Lists
+                if (val instanceof List<?> list) {
+                    Type listType = field.getGenericType();
+                    if (listType instanceof ParameterizedType paramType) {
+                        Type elementType = paramType.getActualTypeArguments()[0];
+
+                        // String List
+                        if (elementType.equals(String.class)) {
+                            configCategory.addEntry(entryBuilder.startStrList(getTranslationKey(baseConfig, config, field.getName()), (List<String>) list)
+                                    .setTooltip(getToolTip(field))
+                                    .setSaveConsumer(newValue -> saveFieldValue(new ArrayList<>(newValue), field, config))
+                                    .setDefaultValue((List<String>) list).build());
+
+                            // Int List
+                        } else if (elementType.equals(Integer.class)) {
+                            configCategory.addEntry(entryBuilder.startIntList(getTranslationKey(baseConfig, config, field.getName()), (List<Integer>) list)
+                                    .setTooltip(getToolTip(field))
+                                    .setSaveConsumer(newValue -> saveFieldValue(new ArrayList<>(newValue), field, config))
+                                    .setDefaultValue((List<Integer>) list).build());
+
+                            // Long List
+                        } else if (elementType.equals(Long.class)) {
+                            configCategory.addEntry(entryBuilder.startLongList(getTranslationKey(baseConfig, config, field.getName()), (List<Long>) list)
+                                    .setTooltip(getToolTip(field))
+                                    .setSaveConsumer(newValue -> saveFieldValue(new ArrayList<>(newValue), field, config))
+                                    .setDefaultValue((List<Long>) list).build());
+
+                            // Float List
+                        } else if (elementType.equals(Float.class)) {
+                            configCategory.addEntry(entryBuilder.startFloatList(getTranslationKey(baseConfig, config, field.getName()), (List<Float>) list)
+                                    .setTooltip(getToolTip(field))
+                                    .setSaveConsumer(newValue -> saveFieldValue(new ArrayList<>(newValue), field, config))
+                                    .setDefaultValue((List<Float>) list).build());
+
+                            // Double List
+                        } else if (elementType.equals(Double.class)) {
+                            configCategory.addEntry(entryBuilder.startDoubleList(getTranslationKey(baseConfig, config, field.getName()), (List<Double>) list)
+                                    .setTooltip(getToolTip(field))
+                                    .setSaveConsumer(newValue -> saveFieldValue(new ArrayList<>(newValue), field, config))
+                                    .setDefaultValue((List<Double>) list).build());
+                        } else {
+                            // List of complex objects
+                            configCategory.addEntry(
+                                    new ClothConfigButtonEntry(
+                                            getTranslationKey(baseConfig, config, field.getName()),
+                                            new TranslatableComponent("cl.buttons.edit"),
+                                            button -> Minecraft.getInstance().setScreen(
+                                                    buildListScreen(baseConfig, list, field, config, builder.build(), false)
+                                            )
+                                    )
+                            );
+                        }
+                    }
+                }
+
+            } catch (Exception e) {
+                CraterConstants.LOG.error("Failed to process config file {}", baseConfig.getConfigName(), e);
+            }
+        }
+    }
+
+    /**
+     * Helper method to supply tooltips to config fields.
+     * If the field has an {@link SpecComment}, we use that, otherwise we use the {@link Tooltip} annotation
+     * or generate one from the field name
+     *
+     * @param field The field that is being processed
+     * @return A {@link Component} that can be used for the tooltip
+     */
+    private static Component getToolTip(Field field) {
+        Component component = new TextComponent("");
+
+        if (field.isAnnotationPresent(SpecComment.class)) {
+            SpecComment comment = field.getAnnotation(SpecComment.class);
+            component = new TextComponent(comment.value());
+        }
+
+        if (field.isAnnotationPresent(Tooltip.class)) {
+            Tooltip tooltip = field.getAnnotation(Tooltip.class);
+            Component c = new TextComponent("");
+
+            for (String comment : tooltip.value()) {
+                c.getSiblings().add(new TextComponent(comment));
+            }
+
+            component = c;
+        }
+
+        return component;
+    }
+
+    /**
+     * A helper method to build translation keys for config screens, fields etc
+     *
+     * @param baseConfig The {@link AbstractConfig} being processed
+     * @param currentConfig The field being processed
+     * @param fieldName The raw name of the field
+     * @return A {@link Component} with the new translation key
+     */
+    private static Component getTranslationKey(AbstractConfig baseConfig, Object currentConfig, String fieldName) {
+        String baseKey = "cl.config." + baseConfig.getClass().getSimpleName().toLowerCase();
+
+        if (currentConfig != baseConfig) {
+            baseKey += "." + currentConfig.getClass().getSimpleName().toLowerCase();
+        }
+
+        if (fieldName != null) {
+            baseKey += "." + fieldName.toLowerCase();
+        }
+
+        return new TranslatableComponent(baseKey);
+    }
+
+    /**
+     * Helper method to write changes values back to the config using reflection
+     *
+     * @param value The new value of the field
+     * @param field The field that needs to be updated
+     * @param config The object used to invoke the field for updating
+     */
+    private static void saveFieldValue(Object value, Field field, Object config) {
+        try {
+            if (value instanceof List && !field.getType().equals(List.class)) {
+                List newList = (List)field.getType().getDeclaredConstructor().newInstance();
+                newList.addAll((List)value);
+                field.set(config, newList);
+            } else {
+                field.set(config, value);
+            }
+        } catch (Exception e) {
+            CraterConstants.LOG.error("Failed to write config field {}", field.getName(), e);
+        }
+    }
+
+    /**
+     * Safety method to prevent config screens from corrupting configs. In some edge cases, the config gui
+     * can generate invalid values, that cause the config saving to fail, and then save an empty file.
+     * This method makes a backup of the config before writing to it, and restores the backup if it fails
+     *
+     * @param config The {@link AbstractConfig} being saved
+     */
+    private static void safeSaveConfig(AbstractConfig config) {
+        File configPath = config.getConfigPath();
+        Path backupPath = configPath.toPath().resolveSibling(configPath.getName() + ".bak");
+
+        try {
+            Files.copy(configPath.toPath(), backupPath, StandardCopyOption.REPLACE_EXISTING);
+            config.saveConfig(config);
+            Files.deleteIfExists(backupPath);
+        } catch (Exception e) {
+            Minecraft.getInstance().getToasts().addToast(
+                    new SystemToast(
+                            SystemToast.SystemToastIds.PACK_LOAD_FAILURE,
+                            new TextComponent("Failed To Save Config"),
+                            new TextComponent("Restoring Backup Copy. Check log for details"))
+            );
+            CraterConstants.LOG.error("Failed to save config, restoring backup", e);
+            try {
+                Files.copy(backupPath, configPath.toPath(), StandardCopyOption.REPLACE_EXISTING);
+                config.configReloaded();
+            } catch (Exception restoreError) {
+                CraterConstants.LOG.error("Failed to restore config backup", restoreError);
+            }
+        }
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/gui/config/CraterConfigScreen.java

@@ -0,0 +1,395 @@
+package com.hypherionmc.craterlib.client.gui.config;
+
+import com.hypherionmc.craterlib.CraterConstants;
+import com.hypherionmc.craterlib.client.gui.config.widgets.*;
+import com.hypherionmc.craterlib.core.config.AbstractConfig;
+import com.hypherionmc.craterlib.core.config.annotations.HideFromScreen;
+import com.hypherionmc.craterlib.core.config.annotations.SubConfig;
+import com.hypherionmc.craterlib.core.config.annotations.Tooltip;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.*;
+import com.mojang.math.Matrix4f;
+import me.hypherionmc.moonconfig.core.conversion.SpecComment;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.screens.ConfirmScreen;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TextComponent;
+import net.minecraft.network.chat.TranslatableComponent;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.Mth;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/**
+ * @author HypherionSA
+ */
+@Deprecated(forRemoval = true, since = "2.1.3")
+public class CraterConfigScreen extends Screen {
+    public static final float SCROLLBAR_BOTTOM_COLOR = .5f;
+    public static final float SCROLLBAR_TOP_COLOR = .67f;
+    private static final int TOP = 26;
+    private static final int BOTTOM = 24;
+    private final Screen parent;
+    private final List<Option<?>> options = new ArrayList<>();
+    private final AbstractConfig config;
+    public double scrollerAmount;
+    private boolean dragging;
+
+    public CraterConfigScreen(AbstractConfig config, Screen parent, Object subConfig) {
+        super(new TranslatableComponent("cl." + config.getClass().getSimpleName().toLowerCase() + ".title"));
+        this.parent = parent;
+        this.config = config;
+        if (subConfig != null) {
+            setupScreenFromConfig(subConfig, subConfig.getClass());
+        } else {
+            setupScreenFromConfig(config, config.getClass());
+        }
+    }
+
+    public CraterConfigScreen(AbstractConfig config, Screen parent) {
+        this(config, parent, null);
+    }
+
+    private static Component toText(Enum<?> val) {
+        return new TranslatableComponent(val.toString());
+    }
+
+    private static Component toText(Boolean bool) {
+        return new TranslatableComponent(bool.toString());
+    }
+
+    private void setupScreenFromConfig(Object object, Class<?> clazz) {
+        while (clazz != Object.class) {
+            for (Field field : clazz.getDeclaredFields()) {
+                final int fieldModifiers = field.getModifiers();
+                if (object == null || Modifier.isStatic(fieldModifiers) || Modifier.isTransient(fieldModifiers)) {
+                    continue;
+                }
+
+                try {
+                    if (!field.isAccessible()) {
+                        field.setAccessible(true);
+                    }
+                    if (field.isAnnotationPresent(HideFromScreen.class))
+                        return;
+                    Object val = field.get(object);
+
+                    /* Lang Stuff */
+                    String baseLangKey = "cl." + clazz.getSimpleName().toLowerCase() + "." + field.getName().toLowerCase();
+                    String[] tooltipLang = field.isAnnotationPresent(SpecComment.class) ? new String[]{field.getAnnotation(SpecComment.class).value()} : new String[0];
+                    if (field.isAnnotationPresent(Tooltip.class)) {
+                        tooltipLang = field.getAnnotation(Tooltip.class).value();
+                    }
+
+                    add(new TranslatableComponent(baseLangKey),
+                            val,
+                            () -> val,
+                            (ret) -> {
+                                try {
+                                    field.set(object, ret);
+                                    config.saveConfig(config);
+                                } catch (IllegalAccessException e) {
+                                    CraterConstants.LOG.error("Failed to update value for field {} in config {}", field.getName(), config.getConfigName(), e);
+                                }
+                            },
+                            field.isAnnotationPresent(SubConfig.class),
+                            tooltipLang
+                    );
+                } catch (IllegalAccessException e) {
+                    CraterConstants.LOG.error("Failed to access value for field {} in config {}", field.getName(), config.getConfigName(), e);
+                }
+            }
+            clazz = clazz.getSuperclass();
+        }
+    }
+
+    public <T> void add(Component text, T value, @Nullable Supplier<T> defaultValue, Consumer<T> savingConsumer, boolean isSubConfig, String... langKeys) {
+        Option<T> option = (Option<T>) createOption(value, isSubConfig);
+        option.text = text;
+        option.defaultValue = defaultValue;
+        option.savingConsumer = savingConsumer;
+        option.originalValue = value;
+        option.value = value;
+        option.setLangKeys(List.of(langKeys));
+        options.add(option);
+        option.onAdd();
+    }
+
+    private <T> Option<?> createOption(T value, boolean isSubConfig) {
+        if (value instanceof Enum) {
+            Object[] objects = value.getClass().getEnumConstants();
+            return new ToggleButton<Enum<?>>((List) Arrays.asList(objects), CraterConfigScreen::toText);
+        }
+        if (value instanceof Boolean) {
+            return new ToggleButton<>(Arrays.asList(Boolean.TRUE, Boolean.FALSE), CraterConfigScreen::toText);
+        }
+        if (value instanceof String) {
+            return new TextConfigOption<>(Function.identity(), Function.identity());
+        }
+        if (value instanceof Integer) {
+            return new TextConfigOption<>(Objects::toString, Integer::valueOf);
+        }
+        if (value instanceof Long) {
+            return new TextConfigOption<>(Objects::toString, Long::valueOf);
+        }
+        if (value instanceof Double) {
+            return new TextConfigOption<>(Objects::toString, Double::valueOf);
+        }
+        if (value instanceof Float) {
+            return new TextConfigOption<>(Objects::toString, Float::valueOf);
+        }
+        if (value instanceof BigInteger) {
+            return new TextConfigOption<>(Objects::toString, BigInteger::new);
+        }
+        if (value instanceof BigDecimal) {
+            return new TextConfigOption<>(Objects::toString, BigDecimal::new);
+        }
+        if (value instanceof ResourceLocation) {
+            return new TextConfigOption<>(Objects::toString, ResourceLocation::new);
+        }
+        if (isSubConfig) {
+            return new SubConfigWidget<>(config, this, value);
+        }
+        throw new IllegalArgumentException(String.valueOf(value));
+    }
+
+    @Override
+    protected void init() {
+        super.init();
+        ((List) children()).addAll(options);
+
+        int buttonWidths = Math.min(200, (width - 50 - 12) / 3);
+        addRenderableWidget(new InternalConfigButton(this, width / 2 - buttonWidths - 3, height - 22, buttonWidths, 20, new TextComponent(""), true));
+        addRenderableWidget(new InternalConfigButton(this, width / 2 + 3, height - 22, buttonWidths, 20, new TextComponent(""), false));
+    }
+
+    @Override
+    public void render(@NotNull PoseStack matrices, int mouseX, int mouseY, float delta) {
+        overlayBackground(matrices, TOP, height - BOTTOM, 32);
+
+        renderScrollBar();
+
+        matrices.pushPose();
+        matrices.translate(0, 0, 500.0);
+        overlayBackground(matrices, 0, TOP, 64);
+        overlayBackground(matrices, height - BOTTOM, height, 64);
+        renderShadow(matrices);
+        drawCenteredString(matrices, font, getTitle(), width / 2, 9, 0xFFFFFF);
+        super.render(matrices, mouseX, mouseY, delta);
+        matrices.popPose();
+
+        int y = (int) (TOP + 4 - Math.round(scrollerAmount));
+        for (Option<?> option : options) {
+            int height1 = option.height();
+            option.render(minecraft, font, 40, y, width - 80, height1, matrices, mouseX, mouseY, delta);
+            renderConfigTooltip(matrices, font, mouseX, mouseY, 40, y, font.width(option.text), height1, option.text.getString(), option.getLangKeys().toArray(new String[0]));
+            y += height1;
+        }
+    }
+
+    private void renderScrollBar() {
+        int listHeight = height - BOTTOM - TOP;
+        int totalHeight = totalHeight();
+        if (totalHeight > listHeight) {
+            int maxScroll = Math.max(0, totalHeight - listHeight);
+            int height = listHeight * listHeight / totalHeight;
+            height = Mth.clamp(height, 32, listHeight);
+            height = Math.max(10, height);
+            int minY = Math.min(Math.max((int) scrollerAmount * (listHeight - height) / maxScroll + TOP, TOP), this.height - BOTTOM - height);
+
+            int scrollbarPositionMaxX = width;
+            int scrollbarPositionMinX = scrollbarPositionMaxX - 6;
+
+            int maxY = this.height - BOTTOM;
+            //RenderSystem.disableTexture();
+            Tesselator tesselator = Tesselator.getInstance();
+            BufferBuilder buffer = tesselator.getBuilder();
+            RenderSystem.setShader(GameRenderer::getPositionColorShader);
+            buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR);
+
+            buffer.vertex(scrollbarPositionMinX, maxY, 0.0D).color(0, 0, 0, 255).endVertex();
+            buffer.vertex(scrollbarPositionMaxX, maxY, 0.0D).color(0, 0, 0, 255).endVertex();
+            buffer.vertex(scrollbarPositionMaxX, TOP, 0.0D).color(0, 0, 0, 255).endVertex();
+            buffer.vertex(scrollbarPositionMinX, TOP, 0.0D).color(0, 0, 0, 255).endVertex();
+
+            buffer.vertex(scrollbarPositionMinX, minY + height, 0.0D).color(SCROLLBAR_BOTTOM_COLOR, SCROLLBAR_BOTTOM_COLOR, SCROLLBAR_BOTTOM_COLOR, 1).endVertex();
+            buffer.vertex(scrollbarPositionMaxX, minY + height, 0.0D).color(SCROLLBAR_BOTTOM_COLOR, SCROLLBAR_BOTTOM_COLOR, SCROLLBAR_BOTTOM_COLOR, 1).endVertex();
+            buffer.vertex(scrollbarPositionMaxX, minY, 0.0D).color(SCROLLBAR_BOTTOM_COLOR, SCROLLBAR_BOTTOM_COLOR, SCROLLBAR_BOTTOM_COLOR, 1).endVertex();
+            buffer.vertex(scrollbarPositionMinX, minY, 0.0D).color(SCROLLBAR_BOTTOM_COLOR, SCROLLBAR_BOTTOM_COLOR, SCROLLBAR_BOTTOM_COLOR, 1).endVertex();
+            buffer.vertex(scrollbarPositionMinX, (minY + height - 1), 0.0D).color(SCROLLBAR_TOP_COLOR, SCROLLBAR_TOP_COLOR, SCROLLBAR_TOP_COLOR, 1).endVertex();
+            buffer.vertex((scrollbarPositionMaxX - 1), (minY + height - 1), 0.0D).color(SCROLLBAR_TOP_COLOR, SCROLLBAR_TOP_COLOR, SCROLLBAR_TOP_COLOR, 1).endVertex();
+            buffer.vertex((scrollbarPositionMaxX - 1), minY, 0.0D).color(SCROLLBAR_TOP_COLOR, SCROLLBAR_TOP_COLOR, SCROLLBAR_TOP_COLOR, 1).endVertex();
+            buffer.vertex(scrollbarPositionMinX, minY, 0.0D).color(SCROLLBAR_TOP_COLOR, SCROLLBAR_TOP_COLOR, SCROLLBAR_TOP_COLOR, 1).endVertex();
+            tesselator.end();
+            RenderSystem.disableBlend();
+            //RenderSystem.enableTexture();
+        }
+    }
+
+    private void renderShadow(PoseStack matrices) {
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder buffer = tesselator.getBuilder();
+        RenderSystem.enableBlend();
+        RenderSystem.blendFuncSeparate(770, 771, 0, 1);
+        //RenderSystem.disableTexture();
+        RenderSystem.setShader(GameRenderer::getPositionTexColorShader);
+        Matrix4f matrix = matrices.last().pose();
+        buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
+        buffer.vertex(matrix, 0, TOP + 4, 0.0F).uv(0, 1).color(0, 0, 0, 0).endVertex();
+        buffer.vertex(matrix, width, TOP + 4, 0.0F).uv(1, 1).color(0, 0, 0, 0).endVertex();
+        buffer.vertex(matrix, width, TOP, 0.0F).uv(1, 0).color(0, 0, 0, 185).endVertex();
+        buffer.vertex(matrix, 0, TOP, 0.0F).uv(0, 0).color(0, 0, 0, 185).endVertex();
+        buffer.vertex(matrix, 0, height - BOTTOM, 0.0F).uv(0, 1).color(0, 0, 0, 185).endVertex();
+        buffer.vertex(matrix, width, height - BOTTOM, 0.0F).uv(1, 1).color(0, 0, 0, 185).endVertex();
+        buffer.vertex(matrix, width, height - BOTTOM - 4, 0.0F).uv(1, 0).color(0, 0, 0, 0).endVertex();
+        buffer.vertex(matrix, 0, height - BOTTOM - 4, 0.0F).uv(0, 0).color(0, 0, 0, 0).endVertex();
+        tesselator.end();
+        //RenderSystem.enableTexture();
+        RenderSystem.disableBlend();
+    }
+
+    protected void overlayBackground(PoseStack matrices, int h1, int h2, int color) {
+        overlayBackground(matrices.last().pose(), 0, h1, width, h2, color, color, color, 255, 255);
+    }
+
+    protected void overlayBackground(Matrix4f matrix, int minX, int minY, int maxX, int maxY, int red, int green, int blue, int startAlpha, int endAlpha) {
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder buffer = tesselator.getBuilder();
+        RenderSystem.setShaderTexture(0, Screen.BACKGROUND_LOCATION);
+        RenderSystem.setShaderColor(1.0f, 1.0f, 1.0f, 1.0f);
+        RenderSystem.setShader(GameRenderer::getPositionTexColorShader);
+        buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
+        buffer.vertex(matrix, minX, maxY, 0.0F).uv(minX / 32.0F, maxY / 32.0F).color(red, green, blue, endAlpha).endVertex();
+        buffer.vertex(matrix, maxX, maxY, 0.0F).uv(maxX / 32.0F, maxY / 32.0F).color(red, green, blue, endAlpha).endVertex();
+        buffer.vertex(matrix, maxX, minY, 0.0F).uv(maxX / 32.0F, minY / 32.0F).color(red, green, blue, startAlpha).endVertex();
+        buffer.vertex(matrix, minX, minY, 0.0F).uv(minX / 32.0F, minY / 32.0F).color(red, green, blue, startAlpha).endVertex();
+        tesselator.end();
+    }
+
+    public int scrollHeight() {
+        int totalHeight = totalHeight();
+        int listHeight = height - BOTTOM - TOP;
+        if (totalHeight <= listHeight) {
+            return 0;
+        }
+        return totalHeight - listHeight;
+    }
+
+    public int totalHeight() {
+        int i = 8;
+        for (Option<?> option : options) {
+            i += option.height();
+        }
+        return i;
+    }
+
+    public boolean hasErrors() {
+        for (Option<?> option : options) {
+            if (option.hasErrors) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean isEdited() {
+        for (Option<?> option : options) {
+            if (option.isEdited()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void save() {
+        for (Option option : options) {
+            option.save();
+            option.originalValue = option.value;
+        }
+    }
+
+    @Override
+    public void onClose() {
+        if (isEdited()) {
+            minecraft.setScreen(new ConfirmScreen(this::acceptConfirm, new TranslatableComponent("t.clc.quit_config"),
+                    new TranslatableComponent("t.clc.quit_config_sure"),
+                    new TranslatableComponent("t.clc.quit_discard"),
+                    new TranslatableComponent("gui.cancel")));
+        } else {
+            minecraft.setScreen(parent);
+        }
+    }
+
+    @Override
+    public boolean mouseScrolled(double d, double e, double f) {
+        if (e >= TOP && e <= height - BOTTOM) {
+            scrollerAmount = Mth.clamp(scrollerAmount - f * 16.0D, 0, scrollHeight());
+            return true;
+        }
+        return super.mouseScrolled(d, e, f);
+    }
+
+    @Override
+    public boolean mouseClicked(double d, double e, int i) {
+        this.dragging = i == 0 && d >= width - 6 && d < width;
+        return super.mouseClicked(d, e, i) || dragging;
+    }
+
+    @Override
+    public boolean mouseDragged(double d, double e, int i, double f, double g) {
+        if (super.mouseDragged(d, e, i, f, g)) {
+            return true;
+        }
+        if (i != 0 || !this.dragging) {
+            return false;
+        }
+        if (e < TOP) {
+            scrollerAmount = 0;
+        } else if (e > height - BOTTOM) {
+            scrollerAmount = scrollHeight();
+        } else {
+            double h = Math.max(1, this.scrollHeight());
+            int j = height - BOTTOM - TOP;
+            int k = Mth.clamp((int) ((float) (j * j) / (float) this.scrollHeight()), 32, j - 8);
+            double l = Math.max(1.0, h / (double) (j - k));
+            scrollerAmount = Mth.clamp(scrollerAmount + g * l, 0, scrollHeight());
+        }
+        return true;
+    }
+
+    private void acceptConfirm(boolean t) {
+        if (!t) {
+            minecraft.setScreen(this);
+        } else {
+            minecraft.setScreen(parent);
+        }
+    }
+
+    private void renderConfigTooltip(PoseStack stack, Font font, int mouseX, int mouseY, int startX, int startY, int sizeX, int sizeY, String title, String... description) {
+        if (mouseX > startX && mouseX < startX + sizeX) {
+            if (mouseY > startY && mouseY < startY + sizeY) {
+                List<Component> list = new ArrayList<>();
+                list.add(new TranslatableComponent(ChatFormatting.BOLD + "" + ChatFormatting.YELLOW + title));
+                for (String desc : description) {
+                    list.add(new TranslatableComponent(desc));
+                }
+                renderComponentTooltip(stack, list, mouseX, mouseY);
+            }
+        }
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/gui/config/widgets/AbstractConfigWidget.java

@@ -0,0 +1,28 @@
+package com.hypherionmc.craterlib.client.gui.config.widgets;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.components.AbstractWidget;
+import net.minecraft.client.gui.components.EditBox;
+
+/**
+ * Copied from Cloth Config Lite
+ * <a href="https://github.com/shedaniel/cloth-config-lite/blob/1.17/src/main/java/me/shedaniel/clothconfiglite/impl/option/AbstractWidgetOption.java">...</a>
+ */
+@Deprecated(forRemoval = true, since = "2.1.3")
+public class AbstractConfigWidget<T, W extends AbstractWidget> extends BaseWidget<T> {
+
+    public static final int buttonWidth = 200;
+    public static final int buttonHeight = 20;
+    public W widget;
+
+    @Override
+    public void render(Minecraft minecraft, Font font, int x, int y, int width, int height, PoseStack matrices, int mouseX, int mouseY, float delta) {
+        super.render(minecraft, font, x, y, width, height, matrices, mouseX, mouseY, delta);
+        int i = (widget instanceof EditBox ? 1 : 0);
+        widget.x = (x + width - 200 - resetButtonOffset + i);
+        widget.y = (y + i + 1);
+        widget.render(matrices, mouseX, mouseY, delta);
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/gui/config/widgets/BaseWidget.java

@@ -0,0 +1,62 @@
+package com.hypherionmc.craterlib.client.gui.config.widgets;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.network.chat.TextColor;
+import net.minecraft.network.chat.TextComponent;
+
+/**
+ * Copied from Cloth Config Lite
+ * <a href="https://github.com/shedaniel/cloth-config-lite/blob/1.17/src/main/java/me/shedaniel/clothconfiglite/impl/option/BaseOption.java">...</a>
+ */
+@Deprecated(forRemoval = true, since = "2.1.3")
+public class BaseWidget<T> extends Option<T> {
+
+    public static final int resetButtonOffset = 48;
+    private final Button resetButton = addChild(new Button(0, 0, 46, 20, new TextComponent("Reset"), this::onResetPressed));
+    private boolean hideReset = false;
+
+    private boolean isSubConfig = false;
+
+    private void onResetPressed(Button button) {
+        value = defaultValue.get();
+        reset();
+    }
+
+    public void hideReset() {
+        this.hideReset = true;
+    }
+
+    public boolean isSubConfig() {
+        return isSubConfig;
+    }
+
+    public void setSubConfig(boolean subConfig) {
+        isSubConfig = subConfig;
+    }
+
+    @Override
+    public void render(Minecraft minecraft, Font font, int x, int y, int width, int height, PoseStack matrices, int mouseX, int mouseY, float delta) {
+        MutableComponent text = new TextComponent(this.text.getString());
+        boolean edited = isEdited() || hasErrors;
+        if (edited) {
+            text.withStyle(ChatFormatting.ITALIC);
+            if (hasErrors) {
+                text.withStyle(style -> style.withColor(TextColor.fromRgb(16733525)));
+            }
+        } else {
+            text.withStyle(ChatFormatting.GRAY);
+        }
+        font.draw(matrices, text, x, y, 0xFFFFFF);
+        resetButton.x = (x + width - 46);
+        resetButton.y = (y + 1);
+        resetButton.active = isNotDefault();
+        if (!hideReset) {
+            resetButton.render(matrices, mouseX, mouseY, delta);
+        }
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/gui/config/widgets/ClothConfigButtonEntry.java

@@ -0,0 +1,129 @@
+package com.hypherionmc.craterlib.client.gui.config.widgets;
+
+import com.mojang.blaze3d.platform.Window;
+import com.mojang.blaze3d.vertex.PoseStack;
+import me.shedaniel.clothconfig2.api.AbstractConfigListEntry;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.narration.NarratableEntry;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TextComponent;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author HypherionSA
+ * A Custom Cloth Config GUI entry to allow buttons to be added to the GUI
+ */
+public class ClothConfigButtonEntry extends AbstractConfigListEntry<Void> {
+
+    private final Button button;
+    private final Button deleteButton;
+    private final Component displayName;
+    private final boolean hasDeleteButton;
+    private final boolean wasEdited;
+
+    /**
+     * Create a new Cloth Button Entry, that will have no delete button
+     *
+     * @param displayName The Display Name that will be used for the field
+     * @param fieldName The Display Name that will be used on the button
+     * @param onPress The Action to perform when the button was pressed
+     */
+    public ClothConfigButtonEntry(Component displayName, Component fieldName, @Nullable Button.OnPress onPress) {
+        this(displayName, fieldName, onPress, null, false);
+    }
+
+    /***
+     * Create a new Cloth Button Entry, with optional delete button
+     *
+     * @param displayName The Display Name that will be used for the field
+     * @param fieldName The Display Name that will be used on the button
+     * @param onPress The Action to perform when the button was pressed
+     * @param deletePress The Action to perform when the delete button is pressed. If this is null, the button is disabled
+     * @param wasEdited Was a change made to the field this button belongs to. This is to tell cloth to enable the save button
+     */
+    public ClothConfigButtonEntry(Component displayName, Component fieldName, Button.OnPress onPress, @Nullable Button.OnPress deletePress, boolean wasEdited) {
+        super(fieldName, false);
+        this.hasDeleteButton = deletePress != null;
+        this.wasEdited = wasEdited;
+
+        int mainButtonWidth = hasDeleteButton ? 75 : 100;
+        this.button = new Button(0, 0, mainButtonWidth, 20, fieldName, onPress);
+        this.deleteButton = deletePress != null ? new Button(0, 0, 20, 20, new TextComponent("X"), deletePress) : null;
+        this.displayName = displayName;
+    }
+
+    @Override
+    public void render(PoseStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean isHovered, float delta) {
+        Window window = Minecraft.getInstance().getWindow();
+        Component displayedFieldName = displayName;
+        if (Minecraft.getInstance().font.isBidirectional()) {
+            drawString(matrices, Minecraft.getInstance().font, displayedFieldName.getVisualOrderText(), window.getGuiScaledWidth() - x - Minecraft.getInstance().font.width(displayedFieldName), y + 6, 16777215);
+            this.button.x = x;
+            if (hasDeleteButton) {
+                this.deleteButton.x = x + this.button.getWidth() + 4;
+            }
+        } else {
+            drawString(matrices, Minecraft.getInstance().font, displayedFieldName.getVisualOrderText(), x, y + 6, this.getPreferredTextColor());
+            if (hasDeleteButton) {
+                this.button.x = x + entryWidth - this.button.getWidth() - 24;
+                this.deleteButton.x = x + entryWidth - 20;
+            } else {
+                this.button.x = x + entryWidth - this.button.getWidth();
+            }
+        }
+
+        button.y = y + (entryHeight - 20) / 2;
+        button.render(matrices, mouseX, mouseY, delta);
+
+        if (hasDeleteButton) {
+            deleteButton.y = y + (entryHeight - 20) / 2;
+            deleteButton.render(matrices, mouseX, mouseY, delta);
+        }
+    }
+
+    @Override
+    public Void getValue() { return null; }
+
+    @Override
+    public Optional<Void> getDefaultValue() { return Optional.empty(); }
+
+    @Override
+    public void save() {}
+
+    @NotNull
+    @Override
+    public List<? extends GuiEventListener> children() {
+        ArrayList<GuiEventListener> children = new ArrayList<>();
+        children.add(button);
+
+        if (hasDeleteButton) {
+            children.add(deleteButton);
+        }
+
+        return children;
+    }
+
+    @Override
+    public List<? extends NarratableEntry> narratables() {
+        ArrayList<NarratableEntry> children = new ArrayList<>();
+        children.add(button);
+
+        if (hasDeleteButton) {
+            children.add(deleteButton);
+        }
+
+        return children;
+    }
+
+    @Override
+    public boolean isEdited() {
+        return wasEdited;
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/gui/config/widgets/InternalConfigButton.java

@@ -0,0 +1,54 @@
+package com.hypherionmc.craterlib.client.gui.config.widgets;
+
+import com.hypherionmc.craterlib.client.gui.config.CraterConfigScreen;
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.gui.components.AbstractButton;
+import net.minecraft.client.gui.narration.NarratedElementType;
+import net.minecraft.client.gui.narration.NarrationElementOutput;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TranslatableComponent;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author HypherionSA
+ */
+@Deprecated(forRemoval = true, since = "2.1.3")
+public class InternalConfigButton extends AbstractButton {
+
+    CraterConfigScreen screen;
+    boolean cancel;
+
+    public InternalConfigButton(CraterConfigScreen screen, int i, int j, int k, int l, Component component, boolean cancel) {
+        super(i, j, k, l, component);
+        this.screen = screen;
+        this.cancel = cancel;
+    }
+
+    @Override
+    public void render(@NotNull PoseStack poseStack, int i, int j, float f) {
+        if (cancel) {
+            setMessage(new TranslatableComponent(screen.isEdited() ? "t.clc.cancel_discard" : "gui.cancel"));
+        } else {
+            boolean hasErrors = screen.hasErrors();
+            active = screen.isEdited() && !hasErrors;
+            setMessage(new TranslatableComponent(hasErrors ? "t.clc.error" : "t.clc.save"));
+        }
+        super.render(poseStack, i, j, f);
+    }
+
+    @Override
+    public void updateNarration(NarrationElementOutput narrationElementOutput) {
+        narrationElementOutput.add(NarratedElementType.USAGE, getMessage());
+    }
+
+    @Override
+    public void onPress() {
+        if (cancel) {
+            screen.onClose();
+        } else {
+            screen.save();
+        }
+    }
+
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/gui/config/widgets/Option.java

@@ -0,0 +1,72 @@
+package com.hypherionmc.craterlib.client.gui.config.widgets;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import lombok.Getter;
+import lombok.Setter;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.components.events.AbstractContainerEventHandler;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.network.chat.Component;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+/**
+ * Copied from Cloth Config Lite
+ * <a href="https://github.com/shedaniel/cloth-config-lite/blob/1.17/src/main/java/me/shedaniel/clothconfiglite/impl/option/Option.java">...</a>
+ */
+@Deprecated(forRemoval = true, since = "2.1.3")
+public abstract class Option<T> extends AbstractContainerEventHandler {
+
+    public Component text;
+    @Nullable
+    public Supplier<T> defaultValue;
+    public Consumer<T> savingConsumer;
+    public T originalValue;
+    public T value;
+    public boolean hasErrors;
+    public List<? extends GuiEventListener> children = new ArrayList<>();
+    @Setter
+    @Getter
+    private List<String> langKeys = new ArrayList<>();
+
+    public abstract void render(Minecraft minecraft, Font font, int x, int y, int width, int height, PoseStack matrices, int mouseX, int mouseY, float delta);
+
+    public int height() {
+        return 22;
+    }
+
+    @Override
+    public List<? extends GuiEventListener> children() {
+        return children;
+    }
+
+    protected <R extends GuiEventListener> R addChild(R listener) {
+        ((List) children).add(listener);
+        return listener;
+    }
+
+    public void onAdd() {
+    }
+
+    protected void reset() {
+        onAdd();
+    }
+
+    public boolean isEdited() {
+        return !Objects.equals(originalValue, value);
+    }
+
+    protected boolean isNotDefault() {
+        return defaultValue != null && !Objects.equals(defaultValue.get(), value);
+    }
+
+    public void save() {
+        savingConsumer.accept(value);
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/gui/config/widgets/SubConfigWidget.java

@@ -0,0 +1,41 @@
+package com.hypherionmc.craterlib.client.gui.config.widgets;
+
+import com.hypherionmc.craterlib.client.gui.config.CraterConfigScreen;
+import com.hypherionmc.craterlib.core.config.AbstractConfig;
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.network.chat.TranslatableComponent;
+
+/**
+ * @author HypherionSA
+ */
+@Deprecated(forRemoval = true, since = "2.1.3")
+public class SubConfigWidget<T> extends AbstractConfigWidget<T, Button> {
+
+    private final Object subConfig;
+    private final AbstractConfig config;
+    private final Screen screen;
+
+    public SubConfigWidget(AbstractConfig config, Screen screen, Object subConfig) {
+        this.config = config;
+        this.subConfig = subConfig;
+        this.screen = screen;
+
+        this.widget = addChild(new Button(0, 0, 200, buttonHeight, new TranslatableComponent("t.clc.opensubconfig"), this::openSubConfig));
+    }
+
+    @Override
+    public void render(Minecraft minecraft, Font font, int x, int y, int width, int height, PoseStack matrices, int mouseX, int mouseY, float delta) {
+        this.text = new TranslatableComponent(subConfig.getClass().getSimpleName().toLowerCase());
+        this.hideReset();
+        super.render(minecraft, font, x, y, width, height, matrices, mouseX, mouseY, delta);
+    }
+
+    private void openSubConfig(Button button) {
+        Minecraft.getInstance().setScreen(new CraterConfigScreen(config, screen, subConfig));
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/gui/config/widgets/TextConfigOption.java

@@ -0,0 +1,46 @@
+package com.hypherionmc.craterlib.client.gui.config.widgets;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+
+import java.util.function.Function;
+
+/**
+ * Copied from Cloth Config Lite
+ * <a href="https://github.com/shedaniel/cloth-config-lite/blob/1.17/src/main/java/me/shedaniel/clothconfiglite/impl/option/TextFieldOption.java">...</a>
+ */
+@Deprecated(forRemoval = true, since = "2.1.3")
+public class TextConfigOption<T> extends AbstractConfigWidget<T, WrappedEditBox> {
+
+    private final Function<T, String> toString;
+    private final Function<String, T> fromString;
+
+    public TextConfigOption(Function<T, String> toString, Function<String, T> fromString) {
+        this.toString = toString;
+        this.fromString = fromString;
+        this.widget = addChild(new WrappedEditBox(Minecraft.getInstance().font, 0, 0, 198, 18, null));
+    }
+
+    @Override
+    public void onAdd() {
+        widget.setMaxLength(1000000);
+        widget.setValue(toString.apply(value));
+        widget.setResponder(this::update);
+    }
+
+    @Override
+    public void render(Minecraft minecraft, Font font, int x, int y, int width, int height, PoseStack matrices, int mouseX, int mouseY, float delta) {
+        widget.setTextColor(hasErrors ? 16733525 : 14737632);
+        super.render(minecraft, font, x, y, width, height, matrices, mouseX, mouseY, delta);
+    }
+
+    private void update(String s) {
+        try {
+            this.value = fromString.apply(s);
+            this.hasErrors = false;
+        } catch (Exception e) {
+            this.hasErrors = true;
+        }
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/gui/config/widgets/ToggleButton.java

@@ -0,0 +1,35 @@
+package com.hypherionmc.craterlib.client.gui.config.widgets;
+
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TextComponent;
+
+import java.util.List;
+import java.util.function.Function;
+
+/**
+ * Copied from Cloth Config Lite
+ * <a href="https://github.com/shedaniel/cloth-config-lite/blob/1.17/src/main/java/me/shedaniel/clothconfiglite/impl/option/ToggleOption.java">...</a>
+ */
+@Deprecated(forRemoval = true, since = "2.1.3")
+public class ToggleButton<T> extends AbstractConfigWidget<T, Button> {
+
+    private final List<T> options;
+    private final Function<T, Component> toComponent;
+
+    public ToggleButton(List<T> options, Function<T, Component> toComponent) {
+        this.options = options;
+        this.toComponent = toComponent;
+        this.widget = addChild(new Button(0, 0, buttonWidth, buttonHeight, new TextComponent(""), this::switchNext));
+    }
+
+    @Override
+    public void onAdd() {
+        widget.setMessage(toComponent.apply(value));
+    }
+
+    private void switchNext(Button button) {
+        value = options.get((options.indexOf(value) + 1) % options.size());
+        onAdd();
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/gui/config/widgets/WrappedEditBox.java

@@ -10,6 +10,7 @@ import org.jetbrains.annotations.NotNull;
 /**
  * @author HypherionSA
  */
+@Deprecated(forRemoval = true, since = "2.1.3")
 public class WrappedEditBox extends EditBox {
 
     public WrappedEditBox(Font font, int i, int j, int k, int l, @NotNull Component component) {

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/compat/FTBEssentials.java

@@ -0,0 +1,17 @@
+// @excludeplugin
+package com.hypherionmc.craterlib.compat;
+
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import dev.ftb.mods.ftbessentials.util.FTBEPlayerData;
+
+import java.util.Optional;
+
+public class FTBEssentials {
+
+    public static boolean isPlayerMuted(BridgedPlayer player) {
+        FTBEPlayerData data = FTBEPlayerData.get(player.toMojang());
+        return data != null && data.muted;
+
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/compat/LuckPermsCompat.java

@@ -0,0 +1,102 @@
+package com.hypherionmc.craterlib.compat;
+
+import com.hypherionmc.craterlib.api.events.compat.LuckPermsCompatEvents;
+import com.hypherionmc.craterlib.core.event.CraterEventBus;
+import net.luckperms.api.LuckPerms;
+import net.luckperms.api.LuckPermsProvider;
+import net.luckperms.api.event.EventBus;
+import net.luckperms.api.event.node.NodeMutateEvent;
+import net.luckperms.api.model.group.Group;
+import net.luckperms.api.model.user.User;
+import net.luckperms.api.node.NodeType;
+import net.luckperms.api.node.types.InheritanceNode;
+import net.minecraft.server.level.ServerPlayer;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
+
+public class LuckPermsCompat {
+
+    public static final LuckPermsCompat INSTANCE = new LuckPermsCompat();
+    private final LuckPerms luckPerms = LuckPermsProvider.get();
+
+    LuckPermsCompat() {
+        EventBus bus = luckPerms.getEventBus();
+
+        bus.subscribe(NodeMutateEvent.class, e -> {
+            if (!e.isUser())
+                return;
+
+            User user = (User) e.getTarget();
+
+            Set<InheritanceNode> addedInheritance = e.getDataAfter().stream()
+                    .filter(node -> node.getType() == NodeType.INHERITANCE && !e.getDataBefore().contains(node))
+                    .map(NodeType.INHERITANCE::cast)
+                    .collect(Collectors.toSet());
+
+            Set<InheritanceNode> removedInheritance = e.getDataBefore().stream()
+                    .filter(node -> node.getType() == NodeType.INHERITANCE && !e.getDataAfter().contains(node))
+                    .map(NodeType.INHERITANCE::cast)
+                    .collect(Collectors.toSet());
+
+            if(addedInheritance.isEmpty() && removedInheritance.isEmpty()) return;
+
+            addedInheritance.forEach(node -> {
+                CraterEventBus.INSTANCE.postEvent(LuckPermsCompatEvents.GroupAddedEvent.of(node.getGroupName(), user.getUniqueId(), user.getUsername()));
+            });
+
+            removedInheritance.forEach(node -> {
+                CraterEventBus.INSTANCE.postEvent(LuckPermsCompatEvents.GroupRemovedEvent.of(node.getGroupName(), user.getUniqueId(), user.getUsername()));
+            });
+        });
+    }
+
+    public boolean hasPermission(ServerPlayer player, String perm) {
+        User luckPermsUser = luckPerms.getPlayerAdapter(ServerPlayer.class).getUser(player);
+        return luckPermsUser.getCachedData().getPermissionData().checkPermission(perm).asBoolean();
+    }
+
+    public boolean hasGroup(UUID uuid, String group) {
+        return getUserGroups(uuid).stream().anyMatch(g -> g.equalsIgnoreCase(group));
+    }
+
+    public Set<String> getUserGroups(UUID uuid) {
+        User user = luckPerms.getUserManager().getUser(uuid);
+        if (user == null)
+            return new HashSet<>();
+
+        return user.getNodes(NodeType.INHERITANCE).stream().map(InheritanceNode::getGroupName).collect(Collectors.toSet());
+    }
+
+    public boolean addGroupToUser(UUID uuid, String group) {
+        AtomicBoolean added = new AtomicBoolean(false);
+
+        Group g = luckPerms.getGroupManager().getGroup(group);
+        if (g == null) {
+            return false;
+        }
+
+        luckPerms.getUserManager().loadUser(uuid).thenAcceptAsync(user -> {
+            if (user == null) return;
+            user.data().add(InheritanceNode.builder(group).build());
+            luckPerms.getUserManager().saveUser(user);
+            added.set(true);
+        });
+
+        return added.get();
+    }
+
+    public boolean removeGroupFromUser(UUID uuid, String group) {
+        AtomicBoolean removed = new AtomicBoolean(false);
+
+        luckPerms.getUserManager().loadUser(uuid).thenAcceptAsync(user -> {
+            if (user == null) return;
+            user.data().remove(InheritanceNode.builder(group).build());
+            luckPerms.getUserManager().saveUser(user);
+            removed.set(true);
+        });
+
+        return removed.get();
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/compat/ftbranks/BridgedRank.java

@@ -0,0 +1,24 @@
+// @excludeplugin
+package com.hypherionmc.craterlib.compat.ftbranks;
+
+import dev.ftb.mods.ftbranks.api.Rank;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedRank {
+
+    private final Rank internal;
+
+    public String name() {
+        return internal.getName();
+    }
+
+    public String id() {
+        return internal.getId();
+    }
+
+    public Rank toFtb() {
+        return internal;
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/compat/ftbranks/FTBRanks.java

@@ -0,0 +1,83 @@
+// @excludeplugin
+package com.hypherionmc.craterlib.compat.ftbranks;
+
+import com.hypherionmc.craterlib.api.events.compat.FTBRankEvents;
+import com.hypherionmc.craterlib.core.event.CraterEventBus;
+import com.hypherionmc.craterlib.nojang.authlib.BridgedGameProfile;
+import dev.ftb.mods.ftbranks.api.FTBRanksAPI;
+import dev.ftb.mods.ftbranks.api.event.PlayerAddedToRankEvent;
+import dev.ftb.mods.ftbranks.api.event.PlayerRemovedFromRankEvent;
+import dev.ftb.mods.ftbranks.api.event.RankDeletedEvent;
+import dev.ftb.mods.ftbranks.api.event.RankEvent;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class FTBRanks {
+
+    public static final FTBRanks INSTANCE = new FTBRanks();
+
+    private FTBRanks() {
+        registerEvents();
+    }
+
+    public List<BridgedRank> getPlayerRanks(BridgedGameProfile profile) {
+        List<BridgedRank> ranks = new ArrayList<>();
+        FTBRanksAPI.INSTANCE.getManager().getAddedRanks(profile.toMojang()).forEach(rank -> ranks.add(BridgedRank.of(rank)));
+        return ranks;
+    }
+
+    public List<BridgedRank> getAllRanks() {
+        List<BridgedRank> ranks = new ArrayList<>();
+        FTBRanksAPI.INSTANCE.getManager().getAllRanks().forEach(r -> ranks.add(BridgedRank.of(r)));
+        return ranks;
+    }
+
+    public boolean hasRank(BridgedGameProfile profile, String rank) {
+        return getPlayerRanks(profile).stream().anyMatch(r -> r.toFtb().getName().equalsIgnoreCase(rank) || r.toFtb().getId().equalsIgnoreCase(rank));
+    }
+
+    public boolean addRank(BridgedGameProfile profile, String rank) {
+        rank = rank.toLowerCase();
+
+        AtomicBoolean didAddRank = new AtomicBoolean(false);
+        FTBRanksAPI.INSTANCE.getManager().getRank(rank).ifPresent(r -> {
+            r.add(profile.toMojang());
+            didAddRank.set(true);
+        });
+
+        return didAddRank.get();
+    }
+
+    public boolean removeRank(BridgedGameProfile profile, String rank) {
+        rank = rank.toLowerCase();
+
+        AtomicBoolean didRemoveRank = new AtomicBoolean(false);
+        FTBRanksAPI.INSTANCE.getManager().getRank(rank).ifPresent(r -> {
+            r.remove(profile.toMojang());
+            didRemoveRank.set(true);
+        });
+
+        return didRemoveRank.get();
+    }
+
+    public void registerEvents() {
+        RankEvent.ADD_PLAYER.register(this::playerAddedToRank);
+        RankEvent.REMOVE_PLAYER.register(this::playerRemovedFromRank);
+        RankEvent.DELETED.register(this::rankDeleted);
+    }
+
+    private void rankDeleted(RankDeletedEvent rankDeletedEvent) {
+        CraterEventBus.INSTANCE.postEvent(FTBRankEvents.RankDeletedEvent.of(rankDeletedEvent.getRank()));
+    }
+
+    private void playerRemovedFromRank(PlayerRemovedFromRankEvent playerRemovedFromRankEvent) {
+        CraterEventBus.INSTANCE.postEvent(FTBRankEvents.RankRemovedEvent.of(playerRemovedFromRankEvent.getPlayer(), playerRemovedFromRankEvent.getRank()));
+    }
+
+    private void playerAddedToRank(PlayerAddedToRankEvent playerAddedToRankEvent) {
+        CraterEventBus.INSTANCE.postEvent(FTBRankEvents.RankAddedEvent.of(playerAddedToRankEvent.getPlayer(), playerAddedToRankEvent.getRank()));
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/config/AbstractConfig.java

@@ -0,0 +1,71 @@
+package com.hypherionmc.craterlib.core.config;
+
+import com.hypherionmc.craterlib.core.config.formats.AbstractConfigFormat;
+import com.hypherionmc.craterlib.core.config.formats.JsonConfigFormat;
+import com.hypherionmc.craterlib.core.config.formats.TomlConfigFormat;
+import lombok.Getter;
+import lombok.Setter;
+import me.hypherionmc.moonconfig.core.Config;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+
+@Getter
+public abstract class AbstractConfig<S> {
+
+    /* Final Variables */
+    private final transient File configPath;
+    private final transient String networkID;
+    private final transient String configName;
+    private final transient String modId;
+    private transient boolean wasSaveCalled = false;
+
+    @Setter
+    private transient AbstractConfigFormat<S> configFormat;
+
+    public AbstractConfig(String modId, String configName) {
+        this(modId, null, configName);
+    }
+
+    public AbstractConfig(String modId, @Nullable String subFolder, String configName) {
+        Config.setInsertionOrderPreserved(true);
+
+        if (!configName.endsWith(".toml") && !configName.endsWith(".json"))
+            configName = configName + ".toml";
+
+        File configDir = new File("config" + (subFolder == null ? "" : File.separator + subFolder));
+        configPath = new File(configDir, configName);
+        this.modId = modId;
+        this.networkID = modId + ":conf_" + configName.replace(".toml", "").replace(".json", "").replace("-", "_").toLowerCase();
+        this.configName = configName.replace(".toml", "").replace(".json", "");
+        configDir.mkdirs();
+
+        configFormat = configName.endsWith(".json") ? new JsonConfigFormat<>(configPath, this::onSave) : new TomlConfigFormat<>(configPath, this::onSave);
+    }
+
+    public void registerAndSetup(S config) {
+        configFormat.register(config);
+        ConfigController.register_config(this);
+        this.configReloaded();
+    }
+
+    public void saveConfig(S config) {
+        this.wasSaveCalled = true;
+        configFormat.saveConfig(config);
+    }
+
+    private void onSave() {
+        this.configReloaded();
+        this.wasSaveCalled = false;
+    }
+
+    public S readConfig(S config) {
+        return configFormat.readConfig(config);
+    }
+
+    public void migrateConfig(S config) {
+        configFormat.migrateConfig(config);
+    }
+
+    public abstract void configReloaded();
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/config/ConfigController.java

@@ -0,0 +1,63 @@
+package com.hypherionmc.craterlib.core.config;
+
+import com.hypherionmc.craterlib.CraterConstants;
+import lombok.Getter;
+import me.hypherionmc.moonconfig.core.file.FileWatcher;
+import org.apache.commons.lang3.tuple.Pair;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.HashSet;
+
+/**
+ * @author HypherionSA
+ * Controls Config File Reloads and Events
+ */
+public final class ConfigController implements Serializable {
+
+    /**
+     * Cache of registered configs
+     */
+    @Getter
+    private static final HashMap<String, AbstractConfig> watchedConfigs = new HashMap<>();
+
+    private static FileWatcher watcher = new FileWatcher(e -> CraterConstants.LOG.error("Config Watcher Error", e));
+
+    /**
+     * INTERNAL METHOD - Register and watch the config
+     *
+     * @param config - The config class to register and watch
+     */
+    @ApiStatus.Internal
+    @Deprecated
+    public static void register_config(ModuleConfig config) {
+        register_config((AbstractConfig) config);
+    }
+
+    /**
+     * INTERNAL METHOD - Register and watch the config
+     *
+     * @param config - The config class to register and watch
+     */
+    @ApiStatus.Internal
+    public static void register_config(AbstractConfig config) {
+        if (watchedConfigs.containsKey(config.getConfigPath().toString())) {
+            CraterConstants.LOG.error("Failed to register {}. Config already registered", config.getConfigPath().getName());
+        } else {
+            try {
+                watcher.addWatch(config.getConfigPath(), () -> {
+                    if (!config.isWasSaveCalled()) {
+                        CraterConstants.LOG.info("Sending Reload Event for: {}", config.getConfigPath().getName());
+                        config.configReloaded();
+                    }
+                });
+            } catch (Exception e) {
+                CraterConstants.LOG.error("Failed to register {} for auto reloading. {}", config.getConfigPath().getName(), e.getMessage());
+            }
+            watchedConfigs.put(config.getConfigPath().toString(), config);
+            CraterConstants.LOG.info("Registered {} successfully!", config.getConfigPath().getName());
+        }
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/config/ModuleConfig.java

@@ -0,0 +1,120 @@
+package com.hypherionmc.craterlib.core.config;
+
+import com.hypherionmc.craterlib.core.config.formats.TomlConfigFormat;
+import me.hypherionmc.moonconfig.core.CommentedConfig;
+
+import java.io.File;
+
+/**
+ * @author HypherionSA
+ * Base Config class containing the save, upgrading and loading logic.
+ * All config classes must extend this class
+ */
+@Deprecated(forRemoval = true, since = "2.1.0")
+public class ModuleConfig extends AbstractConfig {
+
+    /**
+     * Set up the config
+     *
+     * @param modId      - The ID of the Mod/Module the config belongs to
+     * @param configName - The name of the config file, excluding extension
+     */
+    public ModuleConfig(String modId, String configName) {
+        this(modId, "", configName);
+    }
+
+    public ModuleConfig(String modId, String subFolder, String configName) {
+       super(modId, subFolder.isEmpty() ? null : subFolder, configName);
+    }
+
+    /**
+     * This method has to be called in the config constructor. This creates or upgrades the config file as needed
+     *
+     * @param config - The config class to use
+     */
+    public void registerAndSetup(ModuleConfig config) {
+        super.registerAndSetup(config);
+    }
+
+    /**
+     * Save the config to the disk
+     *
+     * @param conf - The config class to serialize and save
+     */
+    public void saveConfig(ModuleConfig conf) {
+       super.registerAndSetup(conf);
+    }
+
+    /**
+     * Load the config from the file into a Class
+     *
+     * @param conf - The config Class to load
+     * @return - Returns the loaded version of the class
+     */
+    public <T> T loadConfig(Object conf) {
+        return (T) super.readConfig(conf);
+    }
+
+    /**
+     * INTERNAL METHOD - Upgrades the config files in the events the config structure changes
+     *
+     * @param conf - The config class to load
+     */
+    public void migrateConfig(ModuleConfig conf) {
+        super.migrateConfig(conf);
+    }
+
+    public void updateConfigValues(CommentedConfig oldConfig, CommentedConfig newConfig, CommentedConfig outputConfig, String subKey) {
+        if (getConfigFormat() instanceof TomlConfigFormat<?> t) {
+            t.updateConfigValues(oldConfig, newConfig, outputConfig, subKey);
+        }
+    }
+
+    /**
+     * Get the location of the config file
+     *
+     * @return - The FILE object containing the config file
+     */
+    public File getConfigPath() {
+        return super.getConfigPath();
+    }
+
+    /**
+     * Get the NETWORK SYNC ID
+     *
+     * @return - Returns the Sync ID in format modid:config_name
+     */
+    public String getNetworkID() {
+        return super.getNetworkID();
+    }
+
+    /**
+     * Fired whenever changes to the config are detected
+     */
+    @Override
+    public void configReloaded() {
+
+    }
+
+    /**
+     * Get the name of the Config File
+     *
+     * @return
+     */
+    public String getConfigName() {
+        return super.getConfigName();
+    }
+
+    /**
+     * Get the MODID of the Module the config is registered to
+     *
+     * @return
+     */
+    public String getModId() {
+        return super.getModId();
+    }
+
+    public boolean isSaveCalled() {
+        return super.isWasSaveCalled();
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/config/annotations/ClothScreen.java

@@ -0,0 +1,12 @@
+package com.hypherionmc.craterlib.core.config.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * @author HypherionSA
+ * Allow mods to make use of the new Cloth Config based Config Screens
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ClothScreen {
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/config/formats/AbstractConfigFormat.java

@@ -0,0 +1,32 @@
+package com.hypherionmc.craterlib.core.config.formats;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import me.hypherionmc.moonconfig.core.Config;
+
+import java.io.File;
+
+@RequiredArgsConstructor
+@Getter
+public abstract class AbstractConfigFormat<S> {
+
+    private final File configPath;
+    private final Runnable onSave;
+
+    public void register(S conf) {
+        if (!configPath.exists() || configPath.length() < 2) {
+            saveConfig(conf);
+        } else {
+            migrateConfig(conf);
+        }
+    }
+
+    public boolean wasConfigChanged(Config old, Config newConfig) {
+        return true;
+    }
+
+    public abstract void saveConfig(S config);
+    public abstract S readConfig(S config);
+    public abstract void migrateConfig(S config);
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/config/formats/JsonConfigFormat.java

@@ -0,0 +1,67 @@
+package com.hypherionmc.craterlib.core.config.formats;
+
+import me.hypherionmc.moonconfig.core.Config;
+import me.hypherionmc.moonconfig.core.conversion.ObjectConverter;
+import me.hypherionmc.moonconfig.core.file.FileConfig;
+
+import java.io.File;
+
+public class JsonConfigFormat<S> extends AbstractConfigFormat<S> {
+
+    public JsonConfigFormat(File configPath, Runnable afterSave) {
+        super(configPath, afterSave);
+    }
+
+    @Override
+    public void saveConfig(S conf) {
+        ObjectConverter converter = new ObjectConverter();
+        FileConfig config = FileConfig.builder(getConfigPath()).sync().build();
+
+        converter.toConfig(conf, config);
+        config.save();
+        getOnSave().run();
+    }
+
+    @Override
+    public S readConfig(S conf) {
+        /* Set up the Serializer and Config Object */
+        ObjectConverter converter = new ObjectConverter();
+        FileConfig config = FileConfig.builder(getConfigPath()).sync().build();
+        config.load();
+
+        /* Load the config and return the loaded config */
+        converter.toObject(config, conf);
+        return conf;
+    }
+
+    @Override
+    public void migrateConfig(S conf) {
+        /* Set up the Serializer and Config Objects */
+        FileConfig config = FileConfig.builder(getConfigPath()).build();
+        FileConfig newConfig = FileConfig.builder(getConfigPath()).sync().build();
+        config.load();
+
+        /* Upgrade the config */
+        if (wasConfigChanged(config, newConfig)) {
+            new ObjectConverter().toConfig(conf, newConfig);
+            updateConfigValues(config, newConfig, newConfig, "");
+            newConfig.save();
+        }
+
+        config.close();
+        newConfig.close();
+    }
+
+    public void updateConfigValues(Config oldConfig, Config newConfig, Config outputConfig, String subKey) {
+        /* Loop over the config keys and check what has changed */
+        newConfig.valueMap().forEach((key, value) -> {
+            String finalKey = subKey + (subKey.isEmpty() ? "" : ".") + key;
+            if (value instanceof Config commentedConfig) {
+                updateConfigValues(oldConfig, commentedConfig, outputConfig, finalKey);
+            } else {
+                outputConfig.set(finalKey,
+                        oldConfig.contains(finalKey) ? oldConfig.get(finalKey) : value);
+            }
+        });
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/config/formats/TomlConfigFormat.java

@@ -0,0 +1,67 @@
+package com.hypherionmc.craterlib.core.config.formats;
+
+import me.hypherionmc.moonconfig.core.CommentedConfig;
+import me.hypherionmc.moonconfig.core.conversion.ObjectConverter;
+import me.hypherionmc.moonconfig.core.file.CommentedFileConfig;
+
+import java.io.File;
+
+public class TomlConfigFormat<S> extends AbstractConfigFormat<S> {
+
+    public TomlConfigFormat(File configPath, Runnable onSave) {
+        super(configPath, onSave);
+    }
+
+    @Override
+    public void saveConfig(S conf) {
+        ObjectConverter converter = new ObjectConverter();
+        CommentedFileConfig config = CommentedFileConfig.builder(getConfigPath()).sync().build();
+
+        converter.toConfig(conf, config);
+        config.save();
+        getOnSave().run();
+    }
+
+    @Override
+    public S readConfig(S conf) {
+        /* Set up the Serializer and Config Object */
+        ObjectConverter converter = new ObjectConverter();
+        CommentedFileConfig config = CommentedFileConfig.builder(getConfigPath()).sync().build();
+        config.load();
+
+        /* Load the config and return the loaded config */
+        converter.toObject(config, conf);
+        return conf;
+    }
+
+    @Override
+    public void migrateConfig(S conf) {
+        /* Set up the Serializer and Config Objects */
+        CommentedFileConfig config = CommentedFileConfig.builder(getConfigPath()).build();
+        CommentedFileConfig newConfig = CommentedFileConfig.builder(getConfigPath()).sync().build();
+        config.load();
+
+        /* Upgrade the config */
+        if (wasConfigChanged(config, newConfig)) {
+            new ObjectConverter().toConfig(conf, newConfig);
+            updateConfigValues(config, newConfig, newConfig, "");
+            newConfig.save();
+        }
+
+        config.close();
+        newConfig.close();
+    }
+
+    public void updateConfigValues(CommentedConfig oldConfig, CommentedConfig newConfig, CommentedConfig outputConfig, String subKey) {
+        /* Loop over the config keys and check what has changed */
+        newConfig.valueMap().forEach((key, value) -> {
+            String finalKey = subKey + (subKey.isEmpty() ? "" : ".") + key;
+            if (value instanceof CommentedConfig commentedConfig) {
+                updateConfigValues(oldConfig, commentedConfig, outputConfig, finalKey);
+            } else {
+                outputConfig.set(finalKey,
+                        oldConfig.contains(finalKey) ? oldConfig.get(finalKey) : value);
+            }
+        });
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/networking/data/PacketHolder.java

@@ -0,0 +1,18 @@
+package com.hypherionmc.craterlib.core.networking.data;
+
+import com.hypherionmc.craterlib.nojang.network.BridgedFriendlyByteBuf;
+import com.hypherionmc.craterlib.nojang.resources.ResourceIdentifier;
+
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/**
+ * Based on https://github.com/mysticdrew/common-networking/tree/1.20.4
+ */
+public record PacketHolder<T>(ResourceIdentifier type,
+                              Class<T> messageType,
+                              BiConsumer<T, BridgedFriendlyByteBuf> encoder,
+                              Function<BridgedFriendlyByteBuf, T> decoder,
+                              Consumer<PacketContext<T>> handler) {
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/platform/CompatUtils.java

@@ -2,6 +2,7 @@ package com.hypherionmc.craterlib.core.platform;
 
 import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
 import com.hypherionmc.craterlib.utils.InternalServiceUtil;
+import net.kyori.adventure.text.Component;
 
 public interface CompatUtils {
 
@@ -9,5 +10,10 @@ public interface CompatUtils {
 
     boolean isPlayerActive(BridgedPlayer player);
     String getSkinUUID(BridgedPlayer player);
+    boolean isPlayerBleeding(BridgedPlayer player);
+    boolean playerBledOut(BridgedPlayer player);
+    boolean playerRevived(BridgedPlayer player);
+    boolean isPrivateMessage(BridgedPlayer player);
+    Component getChannelPrefix(BridgedPlayer player);
 
 }

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/platform/LoaderType.java

@@ -0,0 +1,8 @@
+package com.hypherionmc.craterlib.core.platform;
+
+public enum LoaderType {
+    FABRIC,
+    FORGE,
+    NEOFORGE,
+    PAPER
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/platform/ModloaderEnvironment.java

@@ -12,8 +12,11 @@ public interface ModloaderEnvironment {
 
     public final ModloaderEnvironment INSTANCE = InternalServiceUtil.load(ModloaderEnvironment.class);
 
+    @Deprecated(forRemoval = true, since = "2.0.2")
     boolean isFabric();
 
+    LoaderType getLoaderType();
+
     String getGameVersion();
 
     File getGameFolder();

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/rpcsdk/DiscordEventHandlers.java

@@ -11,6 +11,7 @@ import java.util.List;
  * Class containing references to all available discord event handles.
  * Registering a handler is optional, and non-assigned handlers will be ignored
  */
+@Deprecated(forRemoval = true)
 public class DiscordEventHandlers extends Structure {
 
     // Callback for when the RPC was initialized successfully

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/rpcsdk/DiscordRPC.java

@@ -9,6 +9,7 @@ import org.jetbrains.annotations.Nullable;
  * @author HypherionSA
  * Java Wrapper of the Discord-RPC Library
  */
+@Deprecated(forRemoval = true)
 public interface DiscordRPC extends Library {
 
     DiscordRPC INSTANCE = Native.load("discord-rpc", DiscordRPC.class);

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/rpcsdk/DiscordRichPresence.java

@@ -13,6 +13,7 @@ import java.util.List;
  * @author HypherionSA
  * Class reprenting a Discord RPC activity
  */
+@Deprecated(forRemoval = true)
 public class DiscordRichPresence extends Structure {
 
     // First line of text on the RPC

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/rpcsdk/DiscordUser.java

@@ -9,6 +9,7 @@ import java.util.List;
  * @author HypherionSA
  * Class representing the Discord User
  */
+@Deprecated(forRemoval = true)
 public class DiscordUser extends Structure {
 
     // The User ID of the User

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/rpcsdk/callbacks/DisconnectedCallback.java

@@ -6,6 +6,7 @@ import com.sun.jna.Callback;
  * @author HypherionSA
  * Callback for when the Discord RPC disconnects
  */
+@Deprecated(forRemoval = true)
 public interface DisconnectedCallback extends Callback {
 
     /**

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/rpcsdk/callbacks/ErroredCallback.java

@@ -6,6 +6,7 @@ import com.sun.jna.Callback;
  * @author HypherionSA
  * Callback for when the RPC ran into an error
  */
+@Deprecated(forRemoval = true)
 public interface ErroredCallback extends Callback {
 
     /**

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/rpcsdk/callbacks/JoinGameCallback.java

@@ -6,6 +6,7 @@ import com.sun.jna.Callback;
  * @author HypherionSA
  * Callback for when someone was approved to join your game
  */
+@Deprecated(forRemoval = true)
 public interface JoinGameCallback extends Callback {
 
     /**

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/rpcsdk/callbacks/JoinRequestCallback.java

@@ -7,6 +7,7 @@ import com.sun.jna.Callback;
  * @author HypherionSA
  * Callback for when someone requests to join your game
  */
+@Deprecated(forRemoval = true)
 public interface JoinRequestCallback extends Callback {
 
     /**

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/rpcsdk/callbacks/ReadyCallback.java

@@ -7,6 +7,7 @@ import com.sun.jna.Callback;
  * @author HypherionSA
  * Callback for when the RPC has connected successfully
  */
+@Deprecated(forRemoval = true)
 public interface ReadyCallback extends Callback {
 
     /**

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/rpcsdk/callbacks/SpectateGameCallback.java

@@ -6,6 +6,7 @@ import com.sun.jna.Callback;
  * @author HypherionSA
  * Callback for when someone is requesting to spectate your game
  */
+@Deprecated(forRemoval = true)
 public interface SpectateGameCallback extends Callback {
 
     /**

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/rpcsdk/helpers/RPCButton.java

@@ -9,6 +9,7 @@ import java.io.Serializable;
  * Helper class to add Buttons to Discord Rich Presence
  * This can not be used with Join/Spectate
  */
+@Deprecated(forRemoval = true)
 public class RPCButton implements Serializable {
 
     // The label of the button

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/mixin/events/CommandMixin.java

@@ -0,0 +1,57 @@
+package com.hypherionmc.craterlib.mixin.events;
+
+import com.google.common.base.Throwables;
+import com.hypherionmc.craterlib.api.events.server.CraterCommandEvent;
+import com.hypherionmc.craterlib.core.event.CraterEventBus;
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.ParseResults;
+import com.mojang.brigadier.StringReader;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(Commands.class)
+public class CommandMixin {
+
+    @Shadow
+    @Final
+    private CommandDispatcher<CommandSourceStack> dispatcher;
+
+    @Inject(
+            method = "performCommand",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/util/profiling/ProfilerFiller;push(Ljava/lang/String;)V",
+                    shift = At.Shift.AFTER
+            ),
+            cancellable = true
+    )
+    private void injectCommandEvent(CommandSourceStack stack, String command, CallbackInfoReturnable<Integer> cir) {
+        StringReader stringreader = new StringReader(command);
+        if (stringreader.canRead() && stringreader.peek() == '/') {
+            stringreader.skip();
+        }
+
+        try {
+            ParseResults<CommandSourceStack> parse = dispatcher.parse(stringreader, stack);
+
+            CraterCommandEvent commandEvent = CraterCommandEvent.of(parse, command);
+            CraterEventBus.INSTANCE.postEvent(commandEvent);
+            if (commandEvent.wasCancelled()) {
+                cir.setReturnValue(1);
+                return;
+            }
+
+            if (commandEvent.getException() != null) {
+                Throwables.throwIfUnchecked(commandEvent.getException());
+                cir.setReturnValue(1);
+            }
+        } catch (Exception ignored) {}
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/mixin/events/PlayerAdvancementsMixin.java

@@ -0,0 +1,29 @@
+package com.hypherionmc.craterlib.mixin.events;
+
+import com.hypherionmc.craterlib.api.events.server.CraterAdvancementEvent;
+import com.hypherionmc.craterlib.core.event.CraterEventBus;
+import com.hypherionmc.craterlib.nojang.advancements.BridgedAdvancement;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import net.minecraft.advancements.Advancement;
+import net.minecraft.server.PlayerAdvancements;
+import net.minecraft.server.level.ServerPlayer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(PlayerAdvancements.class)
+public class PlayerAdvancementsMixin {
+
+    @Shadow
+    private ServerPlayer player;
+
+    @Inject(method = "award", at = @At(value = "INVOKE", target = "Lnet/minecraft/advancements/AdvancementRewards;grant(Lnet/minecraft/server/level/ServerPlayer;)V", shift = At.Shift.AFTER))
+    private void injectAdvancementEvent(Advancement advancement, String string, CallbackInfoReturnable<Boolean> cir) {
+        if (advancement.getDisplay() == null || !advancement.getDisplay().shouldAnnounceChat())
+            return;
+
+        CraterEventBus.INSTANCE.postEvent(new CraterAdvancementEvent(BridgedPlayer.of(this.player), BridgedAdvancement.of(advancement)));
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/mixin/events/PlayerListMixin.java

@@ -0,0 +1,53 @@
+package com.hypherionmc.craterlib.mixin.events;
+
+import com.hypherionmc.craterlib.api.events.server.CraterPlayerEvent;
+import com.hypherionmc.craterlib.api.events.server.MessageBroadcastEvent;
+import com.hypherionmc.craterlib.api.events.server.PlayerPreLoginEvent;
+import com.hypherionmc.craterlib.core.event.CraterEventBus;
+import com.hypherionmc.craterlib.nojang.authlib.BridgedGameProfile;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import com.hypherionmc.craterlib.utils.ChatUtils;
+import com.mojang.authlib.GameProfile;
+import net.minecraft.network.Connection;
+import net.minecraft.network.chat.ChatType;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.players.PlayerList;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.net.SocketAddress;
+import java.util.UUID;
+
+@Mixin(PlayerList.class)
+public class PlayerListMixin {
+
+    @Inject(method = "broadcastMessage(Lnet/minecraft/network/chat/Component;Lnet/minecraft/network/chat/ChatType;Ljava/util/UUID;)V", at = @At("HEAD"))
+    private void injectBroadcast(Component component, ChatType chatType, UUID uUID, CallbackInfo ci) {
+        String thread = Thread.currentThread().getStackTrace()[3].getClassName();
+        MessageBroadcastEvent event = new MessageBroadcastEvent(ChatUtils.mojangToAdventure(component), (s) -> null, false, thread);
+        CraterEventBus.INSTANCE.postEvent(event);
+    }
+
+    @Inject(method = "placeNewPlayer", at = @At("TAIL"))
+    private void injectPlayerLoginEvent(Connection arg, ServerPlayer serverPlayer, CallbackInfo ci) {
+        CraterEventBus.INSTANCE.postEvent(new CraterPlayerEvent.PlayerLoggedIn(BridgedPlayer.of(serverPlayer)));
+    }
+
+    @Inject(method = "remove", at = @At("HEAD"))
+    private void injectPlayerLogoutEvent(ServerPlayer player, CallbackInfo ci) {
+        CraterEventBus.INSTANCE.postEvent(new CraterPlayerEvent.PlayerLoggedOut(BridgedPlayer.of(player)));
+    }
+
+    @Inject(method = "canPlayerLogin", at = @At("HEAD"), cancellable = true)
+    private void injectPreLoginEvent(SocketAddress address, GameProfile gameProfile, CallbackInfoReturnable<Component> cir) {
+        PlayerPreLoginEvent event = new PlayerPreLoginEvent(address, BridgedGameProfile.of(gameProfile));
+        CraterEventBus.INSTANCE.postEvent(event);
+        if (event.getMessage() != null) {
+            cir.setReturnValue(ChatUtils.adventureToMojang(event.getMessage()));
+        }
+    }
+}