[DEV] Fix up porting patches and configs

.gitignore

@@ -24,4 +24,6 @@ run
 artifacts
 src/test/**
 dev
-upstream
+upstream
+rejects
+workspace

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,55 @@
+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 1.18.2 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("Publish to Modrinth/Curseforge") {
+            steps {
+                sh "./gradlew publishMod -Prelease=true"
+            }
+        }
+        stage("Publish to Maven") {
+            steps {
+                sh "./gradlew publish -Prelease=true"
+            }
+        }
+    }
+    post {
+        always {
+            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,65 @@
+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("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 {
+                sh "chmod +x ./gradlew"
+                sh "./gradlew build -PreleaseType=port"
+            }
+        }
+
+        stage("Publish to Maven") {
+            steps {
+                catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                    sh "./gradlew publish -PreleaseType=${reltype}"
+                }
+            }
+        }
+    }
+
+    post {
+        always {
+            sh "./gradlew --stop"
+
+            fddsnapshotter apiKey: env.PLATFORM_KEY,
+                projectSlug: "craterlib",
+                projectName: "${projectName}",
+                projectIcon: "${projectIcon}",
+                modLoaders: "${modLoaders}",
+                minecraftVersions: "${supportedMc}",
+                failWebhook: env.SSS_WEBHOOK,
+                publishWebhooks: "${env.SSS_WEBHOOK}|${env.FDD_WH}"
+
+            deleteDir()
+        }
+    }
+}

1.18.2/Common/build.gradle

@@ -0,0 +1,68 @@
+archivesBaseName = "${mod_name.replace(" ", "")}-Common-${minecraft_version}"
+
+dependencies {
+
+}
+
+shadowJar {
+    from sourceSets.main.output
+    configurations = [project.configurations.shade]
+
+    dependencies {
+        exclude(dependency('com.google.code.gson:.*'))
+
+        relocate 'me.hypherionmc.moonconfig', 'shadow.hypherionmc.moonconfig'
+        relocate 'me.hypherionmc.mcdiscordformatter', 'shadow.hypherionmc.mcdiscordformatter'
+        relocate 'net.kyori', 'shadow.kyori'
+    }
+    setArchiveClassifier("dev")
+}
+
+/**
+ * ===============================================================================
+ * =       DO NOT EDIT BELOW THIS LINE UNLESS YOU KNOW WHAT YOU ARE DOING        =
+ * ===============================================================================
+ */
+
+unimined.minecraft {
+    fabric {
+        loader fabric_loader
+    }
+
+    defaultRemapJar = false
+}
+
+processResources {
+    def buildProps = project.properties.clone()
+
+    filesMatching(['pack.mcmeta']) {
+        expand buildProps
+    }
+}
+
+/**
+ * Publishing Config
+ */
+publishing {
+    publications {
+        mavenCommon(MavenPublication) {
+            artifactId project.archivesBaseName
+            from components.java
+
+            pom.withXml {
+                Node pomNode = asNode()
+                pomNode.dependencies.'*'.findAll() {
+                    it.artifactId.text() == 'regutils-joined-fabric' ||
+                            it.artifactId.text() == 'core' ||
+                            it.artifactId.text() == 'toml'
+                }.each() {
+                    it.parent().remove(it)
+                }
+            }
+        }
+    }
+
+    repositories {
+        maven rootProject.orion.getPublishingMaven()
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/CraterConstants.java

@@ -0,0 +1,10 @@
+package com.hypherionmc.craterlib;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CraterConstants {
+    public static final String MOD_ID = "craterlib";
+    public static final String MOD_NAME = "CraterLib";
+    public static final Logger LOG = LoggerFactory.getLogger(MOD_NAME);
+}

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

@@ -0,0 +1,53 @@
+package com.hypherionmc.craterlib.api.commands;
+
+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.arguments.ArgumentType;
+import lombok.Getter;
+import net.minecraft.commands.arguments.GameProfileArgument;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.function.Consumer;
+
+@Getter
+public class CraterCommand {
+
+    private final HashMap<String, Pair<ArgumentType<?>, TriConsumer<?, ?, BridgedCommandSourceStack>>> arguments = new LinkedHashMap<>();
+    private Consumer<BridgedCommandSourceStack> executor;
+
+    private final String commandName;
+    private int permissionLevel = 4;
+
+    CraterCommand(String commandName) {
+        this.commandName = commandName;
+    }
+
+    public static CraterCommand literal(String commandName) {
+        return new CraterCommand(commandName);
+    }
+
+    public CraterCommand requiresPermission(int perm) {
+        this.permissionLevel = perm;
+        return this;
+    }
+
+    public CraterCommand withGameProfileArgument(String key, TriConsumer<BridgedPlayer, List<BridgedGameProfile>, BridgedCommandSourceStack> executor) {
+        arguments.put(key, Pair.of(GameProfileArgument.gameProfile(), executor));
+        return this;
+    }
+
+    public CraterCommand executes(Consumer<BridgedCommandSourceStack> ctx) {
+        executor = ctx;
+        return this;
+    }
+
+    public boolean hasArguments() {
+        return !arguments.isEmpty();
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/client/CraterClientTickEvent.java

@@ -0,0 +1,14 @@
+package com.hypherionmc.craterlib.api.events.client;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.client.multiplayer.BridgedClientLevel;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Getter
+public class CraterClientTickEvent extends CraterEvent {
+
+    private final BridgedClientLevel level;
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/client/CraterSinglePlayerEvent.java

@@ -0,0 +1,21 @@
+package com.hypherionmc.craterlib.api.events.client;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Getter
+public class CraterSinglePlayerEvent extends CraterEvent {
+
+    private final BridgedPlayer player;
+
+    public static class PlayerLogin extends CraterSinglePlayerEvent {
+
+        public PlayerLogin(BridgedPlayer player) {
+            super(player);
+        }
+
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/client/LateInitEvent.java

@@ -0,0 +1,16 @@
+package com.hypherionmc.craterlib.api.events.client;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.client.BridgedMinecraft;
+import com.hypherionmc.craterlib.nojang.client.BridgedOptions;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Getter
+public class LateInitEvent extends CraterEvent {
+
+    private final BridgedMinecraft minecraft;
+    private final BridgedOptions options;
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/client/PlayerJoinRealmEvent.java

@@ -0,0 +1,14 @@
+package com.hypherionmc.craterlib.api.events.client;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.realmsclient.dto.BridgedRealmsServer;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Getter
+public class PlayerJoinRealmEvent extends CraterEvent {
+
+    private final BridgedRealmsServer server;
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/client/ScreenEvent.java

@@ -0,0 +1,27 @@
+package com.hypherionmc.craterlib.api.events.client;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.client.gui.BridgedScreen;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@RequiredArgsConstructor
+public class ScreenEvent extends CraterEvent {
+
+    private final BridgedScreen screen;
+
+    @Getter
+    public static class Opening extends ScreenEvent {
+
+        private final BridgedScreen currentScreen;
+        @Setter private BridgedScreen newScreen;
+
+        public Opening(BridgedScreen currentScreen, BridgedScreen newScreen) {
+            super(newScreen);
+            this.currentScreen = currentScreen;
+            this.newScreen = newScreen;
+        }
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/events/common/CraterPlayerDeathEvent.java

@@ -0,0 +1,21 @@
+package com.hypherionmc.craterlib.api.events.common;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import com.hypherionmc.craterlib.utils.ChatUtils;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import net.kyori.adventure.text.Component;
+import net.minecraft.world.damagesource.DamageSource;
+
+@RequiredArgsConstructor
+@Getter
+public class CraterPlayerDeathEvent extends CraterEvent {
+
+    private final BridgedPlayer player;
+    private final DamageSource damageSource;
+
+    public Component getDeathMessage() {
+        return ChatUtils.mojangToAdventure(damageSource.getLocalizedDeathMessage(player.toMojang()));
+    }
+}

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

@@ -0,0 +1,34 @@
+package com.hypherionmc.craterlib.api.events.server;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.advancements.BridgedAdvancement;
+import com.hypherionmc.craterlib.nojang.advancements.BridgedDisplayInfo;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import lombok.Getter;
+import net.kyori.adventure.text.Component;
+
+import java.util.Optional;
+
+@Getter
+public class CraterAdvancementEvent extends CraterEvent {
+
+    private final BridgedAdvancement advancement;
+    private final BridgedPlayer player;
+    private final Component title;
+    private final Component description;
+
+    public CraterAdvancementEvent(BridgedPlayer player, BridgedAdvancement advancement) {
+        this.advancement = advancement;
+        this.player = player;
+
+        Optional<BridgedDisplayInfo> displayInfo = advancement.displayInfo();
+
+        if (displayInfo.isPresent()) {
+            this.title = displayInfo.get().displayName();
+            this.description = displayInfo.get().description();
+        } else {
+            this.title = Component.text("Unknown");
+            this.description = Component.text("Unknown");
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+package com.hypherionmc.craterlib.api.events.server;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Getter
+public class CraterPlayerEvent extends CraterEvent {
+
+    private final BridgedPlayer player;
+
+    public static class PlayerLoggedIn extends CraterPlayerEvent {
+
+        public PlayerLoggedIn(BridgedPlayer player) {
+            super(player);
+        }
+
+    }
+
+    public static class PlayerLoggedOut extends CraterPlayerEvent {
+
+        public PlayerLoggedOut(BridgedPlayer player) {
+            super(player);
+        }
+
+    }
+
+}

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

@@ -0,0 +1,15 @@
+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;
+
+@NoArgsConstructor
+public class CraterRegisterCommandEvent extends CraterEvent {
+
+    public void registerCommand(CraterCommand cmd) {
+        CommandsRegistry.INSTANCE.registerCommand(cmd);
+    }
+
+}

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

@@ -0,0 +1,25 @@
+package com.hypherionmc.craterlib.api.events.server;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.core.event.annot.Cancellable;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import lombok.Getter;
+import lombok.Setter;
+import net.kyori.adventure.text.Component;
+
+@Cancellable
+@Getter
+public class CraterServerChatEvent extends CraterEvent {
+
+    public final String message, username;
+    public final BridgedPlayer player;
+    @Setter private Component component;
+
+    public CraterServerChatEvent(BridgedPlayer player, String message, Component component) {
+        this.message = message;
+        this.player = player;
+        this.username = player.getGameProfile().getName();
+        this.component = component;
+    }
+
+}

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

@@ -0,0 +1,34 @@
+package com.hypherionmc.craterlib.api.events.server;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.server.BridgedMinecraftServer;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+public class CraterServerLifecycleEvent extends CraterEvent {
+
+    @RequiredArgsConstructor
+    @Getter
+    public static class Starting extends CraterServerLifecycleEvent {
+        private final BridgedMinecraftServer server;
+    }
+
+    @RequiredArgsConstructor
+    @Getter
+    public static class Started extends CraterServerLifecycleEvent {
+        private final BridgedMinecraftServer server;
+    }
+
+    @RequiredArgsConstructor
+    @Getter
+    public static class Stopping extends CraterServerLifecycleEvent {
+        private final BridgedMinecraftServer server;
+    }
+
+    @RequiredArgsConstructor
+    @Getter
+    public static class Stopped extends CraterServerLifecycleEvent {
+        private final BridgedMinecraftServer server;
+    }
+
+}

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

@@ -0,0 +1,20 @@
+package com.hypherionmc.craterlib.api.events.server;
+
+import com.hypherionmc.craterlib.core.event.CraterEvent;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import net.kyori.adventure.text.Component;
+
+import java.util.function.Function;
+
+@RequiredArgsConstructor
+@Getter
+public class MessageBroadcastEvent extends CraterEvent {
+
+    private final Component component;
+    private final Function<BridgedPlayer, Component> function;
+    private final boolean bl;
+    private final String threadName;
+
+}

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

@@ -0,0 +1,20 @@
+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;
+import lombok.Setter;
+import net.kyori.adventure.text.Component;
+
+import java.net.SocketAddress;
+
+@RequiredArgsConstructor
+@Getter
+public class PlayerPreLoginEvent extends CraterEvent {
+
+    private final SocketAddress address;
+    private final BridgedGameProfile gameProfile;
+    @Setter private Component message;
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/api/networking/CraterNetworkHandler.java

@@ -0,0 +1,28 @@
+package com.hypherionmc.craterlib.api.networking;
+
+import com.hypherionmc.craterlib.nojang.server.BridgedMinecraftServer;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+
+import java.util.List;
+
+/**
+ * Based on https://github.com/mysticdrew/common-networking/tree/1.20.4
+ */
+public interface CraterNetworkHandler {
+
+    <T> void sendToServer(T packet);
+
+    <T> void sendToServer(T packet, boolean ignoreCheck);
+
+    <T> void sendToClient(T packet, BridgedPlayer player);
+
+    default <T> void sendToClients(T packet, List<BridgedPlayer> players) {
+        for (BridgedPlayer player : players) {
+            sendToClient(packet, player);
+        }
+    }
+
+    default <T> void sendToAllClients(T packet, BridgedMinecraftServer server) {
+        sendToClients(packet, server.getPlayers());
+    }
+}

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

@@ -0,0 +1,394 @@
+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.ModuleConfig;
+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
+ */
+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 ModuleConfig config;
+    public double scrollerAmount;
+    private boolean dragging;
+
+    public CraterConfigScreen(ModuleConfig 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(ModuleConfig 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,27 @@
+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>
+ */
+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,61 @@
+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>
+ */
+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/InternalConfigButton.java

@@ -0,0 +1,53 @@
+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
+ */
+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,71 @@
+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>
+ */
+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,40 @@
+package com.hypherionmc.craterlib.client.gui.config.widgets;
+
+import com.hypherionmc.craterlib.client.gui.config.CraterConfigScreen;
+import com.hypherionmc.craterlib.core.config.ModuleConfig;
+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
+ */
+public class SubConfigWidget<T> extends AbstractConfigWidget<T, Button> {
+
+    private final Object subConfig;
+    private final ModuleConfig config;
+    private final Screen screen;
+
+    public SubConfigWidget(ModuleConfig 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,45 @@
+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>
+ */
+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,34 @@
+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>
+ */
+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

@@ -0,0 +1,29 @@
+package com.hypherionmc.craterlib.client.gui.config.widgets;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.components.EditBox;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.network.chat.Component;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author HypherionSA
+ */
+public class WrappedEditBox extends EditBox {
+
+    public WrappedEditBox(Font font, int i, int j, int k, int l, @NotNull Component component) {
+        super(font, i, j, k, l, component);
+    }
+
+    @Override
+    public void setFocused(boolean bl) {
+        for (GuiEventListener child : Minecraft.getInstance().screen.children()) {
+            if (child instanceof TextConfigOption<?> option) {
+                WrappedEditBox box = option.widget;
+                super.setFocused(box == this);
+            }
+        }
+        super.setFocused(bl);
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/mentions/MentionCondition.java

@@ -0,0 +1,13 @@
+package com.hypherionmc.craterlib.client.mentions;
+
+/**
+ * Based on <a href="https://github.com/SarahIsWeird/MoreChatSuggestions/blob/main/src/main/java/com/sarahisweird/morechatsuggestions/SuggestionCondition.java">...</a>
+ */
+@FunctionalInterface
+public interface MentionCondition {
+
+    boolean shouldAddMention(String currentWord);
+
+    MentionCondition ALWAYS = currentWord -> true;
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/client/mentions/MentionsController.java

@@ -0,0 +1,47 @@
+package com.hypherionmc.craterlib.client.mentions;
+
+import com.hypherionmc.craterlib.nojang.resources.ResourceIdentifier;
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Based on <a href="https://github.com/SarahIsWeird/MoreChatSuggestions/blob/main/src/main/java/com/sarahisweird/morechatsuggestions/client/MoreChatSuggestions.java">...</a>
+ */
+public class MentionsController {
+
+    private static final Map<ResourceIdentifier, Collection<String>> mentions = new LinkedHashMap<>();
+    private static final Map<ResourceIdentifier, MentionCondition> mentionConditions = new LinkedHashMap<>();
+    @Getter
+    private static boolean lastMentionConditional = true;
+
+    public static void registerMention(ResourceIdentifier mentionClass, Collection<String> suggestions, MentionCondition condition) {
+        mentions.put(mentionClass, suggestions);
+        mentionConditions.put(mentionClass, condition);
+    }
+
+    public static Collection<String> getMentions(String currentWord) {
+        ArrayList<String> applicableMentions = new ArrayList<>();
+        lastMentionConditional = false;
+
+        mentionConditions.forEach((mention, condition) -> {
+            boolean shouldSuggest = condition.shouldAddMention(currentWord);
+            if (!shouldSuggest) return;
+
+            if (!lastMentionConditional && condition != MentionCondition.ALWAYS) {
+                lastMentionConditional = true;
+            }
+
+            applicableMentions.addAll(mentions.get(mention));
+        });
+
+        return applicableMentions;
+    }
+
+    public static boolean hasMentions() {
+        return !mentions.isEmpty();
+    }
+}

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

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

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

@@ -0,0 +1,184 @@
+package com.hypherionmc.craterlib.core.config;
+
+import me.hypherionmc.moonconfig.core.CommentedConfig;
+import me.hypherionmc.moonconfig.core.Config;
+import me.hypherionmc.moonconfig.core.conversion.ObjectConverter;
+import me.hypherionmc.moonconfig.core.file.CommentedFileConfig;
+
+import java.io.File;
+
+/**
+ * @author HypherionSA
+ * Base Config class containing the save, upgrading and loading logic.
+ * All config classes must extend this class
+ */
+public class ModuleConfig {
+
+    /* 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 isSaveCalled = false;
+
+    /**
+     * 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) {
+        /* Preserve the order of the config values */
+        Config.setInsertionOrderPreserved(true);
+
+        /* Configure Paths and Network SYNC ID */
+        File configDir = new File("config" + (subFolder.isEmpty() ? "" : File.separator + subFolder));
+        configPath = new File(configDir + File.separator + configName + ".toml");
+        networkID = modId + ":conf_" + configName.replace("-", "_");
+        this.modId = modId;
+        this.configName = configName;
+
+        /* Check if the required directories exists, otherwise we create them */
+        if (!configDir.exists()) {
+            configDir.mkdirs();
+        }
+    }
+
+    /**
+     * 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) {
+        if (!configPath.exists() || configPath.length() < 2) {
+            saveConfig(config);
+        } else {
+            migrateConfig(config);
+        }
+        /* Register the Config for Watching and events */
+        ConfigController.register_config(this);
+        this.configReloaded();
+    }
+
+    /**
+     * Save the config to the disk
+     *
+     * @param conf - The config class to serialize and save
+     */
+    public void saveConfig(ModuleConfig conf) {
+        this.isSaveCalled = true;
+        /* Set up the Serializer and Config Object */
+        ObjectConverter converter = new ObjectConverter();
+        CommentedFileConfig config = CommentedFileConfig.builder(configPath).build();
+
+        /* Save the config and fire the reload events */
+        converter.toConfig(conf, config);
+        config.save();
+        configReloaded();
+        this.isSaveCalled = false;
+    }
+
+    /**
+     * 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) {
+        /* Set up the Serializer and Config Object */
+        ObjectConverter converter = new ObjectConverter();
+        CommentedFileConfig config = CommentedFileConfig.builder(configPath).build();
+        config.load();
+
+        /* Load the config and return the loaded config */
+        converter.toObject(config, conf);
+        return (T) 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) {
+        /* Set up the Serializer and Config Objects */
+        CommentedFileConfig config = CommentedFileConfig.builder(configPath).build();
+        CommentedFileConfig newConfig = CommentedFileConfig.builder(configPath).build();
+        config.load();
+
+        /* Upgrade the config */
+        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);
+            }
+        });
+    }
+
+    /**
+     * Get the location of the config file
+     *
+     * @return - The FILE object containing the config file
+     */
+    public File getConfigPath() {
+        return configPath;
+    }
+
+    /**
+     * Get the NETWORK SYNC ID
+     *
+     * @return - Returns the Sync ID in format modid:config_name
+     */
+    public String getNetworkID() {
+        return networkID;
+    }
+
+    /**
+     * Fired whenever changes to the config are detected
+     */
+    public void configReloaded() {
+
+    }
+
+    /**
+     * Get the name of the Config File
+     *
+     * @return
+     */
+    public String getConfigName() {
+        return configName;
+    }
+
+    /**
+     * Get the MODID of the Module the config is registered to
+     *
+     * @return
+     */
+    public String getModId() {
+        return modId;
+    }
+
+    public boolean isSaveCalled() {
+        return isSaveCalled;
+    }
+}

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

@@ -0,0 +1,8 @@
+package com.hypherionmc.craterlib.core.config.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface HideFromScreen {
+}

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

@@ -0,0 +1,12 @@
+package com.hypherionmc.craterlib.core.config.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * @author HypherionSA
+ * Allows Modules to disable Automatic Config Screens
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface NoConfigScreen {
+}

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

@@ -0,0 +1,16 @@
+package com.hypherionmc.craterlib.core.config.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author HypherionSA
+ * Used to determine if a Config section should be rendered as a separate screen
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface SubConfig {
+}
+

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

@@ -0,0 +1,15 @@
+package com.hypherionmc.craterlib.core.config.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author HypherionSA
+ * //TODO Currently unused, but to be used with Config Syncing in the future
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface Syncable {
+}

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

@@ -0,0 +1,16 @@
+package com.hypherionmc.craterlib.core.config.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author HypherionSA
+ * Provides tooltips to the config GUI
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface Tooltip {
+    String[] value();
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/event/CraterEvent.java

@@ -0,0 +1,30 @@
+package com.hypherionmc.craterlib.core.event;
+
+import com.hypherionmc.craterlib.core.event.annot.Cancellable;
+import com.hypherionmc.craterlib.core.event.exception.CraterEventCancellationException;
+
+public class CraterEvent {
+
+    private boolean canceled = false;
+
+    private boolean canCancel() {
+        return this.getClass().isAnnotationPresent(Cancellable.class);
+    }
+
+    public void cancelEvent() {
+        try {
+            if (!this.canCancel()) {
+                throw new CraterEventCancellationException("Tried to cancel non-cancelable event: " + this.getClass().getName());
+            }
+
+            this.canceled = true;
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public boolean wasCancelled() {
+        return this.canceled;
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/event/CraterEventBus.java

@@ -0,0 +1,241 @@
+package com.hypherionmc.craterlib.core.event;
+
+import com.hypherionmc.craterlib.CraterConstants;
+import com.hypherionmc.craterlib.core.event.annot.CraterEventListener;
+import org.slf4j.Logger;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.*;
+import java.util.function.Consumer;
+
+public final class CraterEventBus {
+
+    public static final CraterEventBus INSTANCE = new CraterEventBus();
+    private static final Logger LOGGER = CraterConstants.LOG;
+    private final Map<Class<? extends CraterEvent>, List<ListenerContainer>> events = new HashMap<>();
+
+    public void postEvent(CraterEvent event) {
+        if (eventsRegisteredForType(event.getClass())) {
+            List<ListenerContainer> l = new ArrayList<>(events.get(event.getClass()));
+            l.sort((o1, o2) -> Integer.compare(o2.priority, o1.priority));
+
+            for (ListenerContainer c : l) {
+                c.notifyListener(event);
+            }
+        }
+    }
+
+    public void registerEventListener(Class<?> clazz) {
+        this.registerListenerMethods(this.getEventMethodsOf(clazz));
+    }
+
+    public void registerEventListener(Object object) {
+        this.registerListenerMethods(this.getEventMethodsOf(object));
+    }
+
+    private void registerListenerMethods(List<EventMethod> methods) {
+        for (EventMethod m : methods) {
+            Consumer<CraterEvent> listener = (event) -> {
+                try {
+                    m.method.invoke(m.parentObject, event);
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            };
+
+            ListenerContainer container = new ListenerContainer(m.eventType, listener, m.priority);
+            container.listenerParentClassName = m.parentClass.getName();
+            container.listenerMethodName = m.method.getName();
+            this.registerListener(container);
+        }
+    }
+
+    private List<EventMethod> getEventMethodsOf(Object objectOrClass) {
+        List<EventMethod> l = new ArrayList<>();
+        try {
+            if (objectOrClass != null) {
+                boolean isClass = (objectOrClass instanceof Class<?>);
+                Class<?> c = isClass ? (Class<?>) objectOrClass : objectOrClass.getClass();
+                for (Method m : c.getMethods()) {
+                    if (isClass && Modifier.isStatic(m.getModifiers())) {
+                        EventMethod em = EventMethod.tryCreateFrom(new AnalyzedMethod(m, c));
+                        if ((em != null) && this.hasEventAnnotation(em)) l.add(em);
+                    }
+                    if (!isClass && !Modifier.isStatic(m.getModifiers())) {
+                        EventMethod em = EventMethod.tryCreateFrom(new AnalyzedMethod(m, objectOrClass));
+                        if ((em != null) && this.hasEventAnnotation(em)) l.add(em);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return l;
+    }
+
+    private boolean hasEventAnnotation(EventMethod m) {
+        for (Annotation a : m.annotations) {
+            if (a instanceof CraterEventListener) return true;
+        }
+        return false;
+    }
+
+    public void registerListener(Consumer<CraterEvent> listener, Class<? extends CraterEvent> eventType) {
+        this.registerListener(listener, eventType, 0);
+    }
+
+    public void registerListener(Consumer<CraterEvent> listener, Class<? extends CraterEvent> eventType, int priority) {
+        this.registerListener(new ListenerContainer(eventType, listener, priority));
+    }
+
+    private void registerListener(ListenerContainer listenerContainer) {
+        try {
+            if (!eventsRegisteredForType(listenerContainer.eventType)) {
+                events.put(listenerContainer.eventType, new ArrayList<>());
+            }
+            events.get(listenerContainer.eventType).add(listenerContainer);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public boolean eventsRegisteredForType(Class<? extends CraterEvent> eventType) {
+        if (eventType == null) {
+            return false;
+        }
+        return this.events.containsKey(eventType);
+    }
+
+    protected final static class ListenerContainer {
+
+        private final Consumer<CraterEvent> listener;
+        private final Class<? extends CraterEvent> eventType;
+        private final int priority;
+        private String listenerParentClassName = "[unknown]";
+        private String listenerMethodName = "[unknown]";
+
+        private ListenerContainer(Class<? extends CraterEvent> eventType, Consumer<CraterEvent> listener, int priority) {
+            this.eventType = eventType;
+            this.listener = listener;
+            this.priority = priority;
+        }
+
+        private void notifyListener(CraterEvent event) {
+            try {
+                this.listener.accept(event);
+            } catch (Exception e) {
+                LOGGER.error("##################################");
+                LOGGER.error("Failed to notify event listener!");
+                LOGGER.error("Event Type: " + this.eventType.getName());
+                LOGGER.error("Listener Parent Class Name: " + this.listenerParentClassName);
+                LOGGER.error("Listener Method Name In Parent Class: " + this.listenerMethodName);
+                LOGGER.error("##################################");
+                e.printStackTrace();
+            }
+        }
+    }
+
+    protected static class AnalyzedMethod {
+
+        protected Method method;
+        protected Object parentObject;
+        protected Class<?> parentClass;
+        protected boolean isStatic;
+        protected List<Annotation> annotations = new ArrayList<>();
+
+        protected AnalyzedMethod() {
+        }
+
+        protected AnalyzedMethod(Method method, Object parentObjectOrClass) {
+            this.method = method;
+            this.parentObject = parentObjectOrClass;
+            this.parentClass = this.tryGetParentClass();
+            this.isStatic = Modifier.isStatic(method.getModifiers());
+            collectMethodAnnotations(this.isStatic ? null : this.parentObject.getClass(), this.method, this.annotations);
+        }
+
+        protected static void collectMethodAnnotations(Class<?> c, Method m, List<Annotation> addToList) {
+            try {
+                addToList.addAll(Arrays.asList(m.getAnnotations()));
+                if (!Modifier.isStatic(m.getModifiers()) && (c != null)) {
+                    Class<?> sc = c.getSuperclass();
+                    if (sc != null) {
+                        try {
+                            Method sm = sc.getMethod(m.getName(), m.getParameterTypes());
+                            collectMethodAnnotations(sc, sm, addToList);
+                        } catch (Exception ignored) {
+                        }
+                    }
+                }
+            } catch (Exception ignored) {
+            }
+        }
+
+        protected Class<?> tryGetParentClass() {
+            if (this.parentObject instanceof Class<?>) {
+                return (Class<?>) this.parentObject;
+            }
+            return this.parentObject.getClass();
+        }
+
+    }
+
+    protected static class EventMethod extends AnalyzedMethod {
+
+        protected final int priority;
+        protected final Class<? extends CraterEvent> eventType;
+
+        protected EventMethod(AnalyzedMethod method) {
+
+            super();
+            this.method = method.method;
+            this.parentObject = method.parentObject;
+            this.parentClass = method.parentClass;
+            this.isStatic = method.isStatic;
+            this.annotations = method.annotations;
+
+            this.priority = this.tryGetPriority();
+            this.eventType = this.tryGetEventType();
+
+        }
+
+        protected static EventMethod tryCreateFrom(AnalyzedMethod method) {
+            EventMethod em = new EventMethod(method);
+            return (em.eventType != null) ? em : null;
+        }
+
+        protected Class<? extends CraterEvent> tryGetEventType() {
+            try {
+                if (this.method != null) {
+                    Class<?>[] params = this.method.getParameterTypes();
+                    if (params.length > 0) {
+                        Class<?> firstParam = params[0];
+                        if (CraterEvent.class.isAssignableFrom(firstParam)) {
+                            return (Class<? extends CraterEvent>) firstParam;
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            return null;
+        }
+
+        protected int tryGetPriority() {
+            try {
+                for (Annotation a : this.annotations) {
+                    if (a instanceof CraterEventListener craterEventListener) {
+                        return craterEventListener.priority();
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            return 0;
+        }
+
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/event/CraterEventPriority.java

@@ -0,0 +1,13 @@
+package com.hypherionmc.craterlib.core.event;
+
+public class CraterEventPriority {
+
+    public static final int LOWEST = -3;
+    public static final int LOWER = -2;
+    public static final int LOW = -1;
+    public static final int NORMAL = 0;
+    public static final int HIGH = 1;
+    public static final int HIGHER = 2;
+    public static final int HIGHEST = 3;
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/event/annot/Cancellable.java

@@ -0,0 +1,8 @@
+package com.hypherionmc.craterlib.core.event.annot;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Cancellable {
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/event/annot/CraterEventListener.java

@@ -0,0 +1,11 @@
+package com.hypherionmc.craterlib.core.event.annot;
+
+import com.hypherionmc.craterlib.core.event.CraterEventPriority;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CraterEventListener {
+    int priority() default CraterEventPriority.NORMAL;
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/event/exception/CraterEventCancellationException.java

@@ -0,0 +1,9 @@
+package com.hypherionmc.craterlib.core.event.exception;
+
+public class CraterEventCancellationException extends Exception {
+
+    public CraterEventCancellationException(String msg) {
+        super(msg);
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/core/event/package-info.java

@@ -0,0 +1,5 @@
+/**
+ * The event system code in this package is based on, and adapted from Acara (https://github.com/Keksuccino/acara/)
+ * and is licensed under MIT by Keksuccino
+ */
+package com.hypherionmc.craterlib.core.event;

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

@@ -0,0 +1,43 @@
+package com.hypherionmc.craterlib.core.networking;
+
+import com.hypherionmc.craterlib.core.networking.data.PacketContext;
+import com.hypherionmc.craterlib.nojang.network.BridgedFriendlyByteBuf;
+import com.hypherionmc.craterlib.nojang.resources.ResourceIdentifier;
+import lombok.Getter;
+
+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
+ */
+@Getter
+public class CraterPacketNetwork {
+
+    private final PacketRegistry packetRegistry;
+    public static CraterPacketNetwork INSTANCE;
+    private static DeferredPacketRegistrar delayedHandler;
+
+    public CraterPacketNetwork(PacketRegistry registry) {
+        INSTANCE = this;
+        this.packetRegistry = registry;
+        getDelayedHandler().registerQueuedPackets(registry);
+    }
+
+    private static DeferredPacketRegistrar getDelayedHandler() {
+        if (delayedHandler == null) {
+            delayedHandler = new DeferredPacketRegistrar();
+        }
+        return delayedHandler;
+    }
+
+    public static <T> PacketRegistrar registerPacket(ResourceIdentifier id, Class<T> messageType, BiConsumer<T, BridgedFriendlyByteBuf> encoder, Function<BridgedFriendlyByteBuf, T> decoder, Consumer<PacketContext<T>> handler) {
+        if (INSTANCE != null) {
+            return INSTANCE.packetRegistry.registerPacket(id, messageType, encoder, decoder, handler);
+        } else {
+            return getDelayedHandler().registerPacket(id, messageType, encoder, decoder, handler);
+        }
+    }
+
+}

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

@@ -0,0 +1,41 @@
+package com.hypherionmc.craterlib.core.networking;
+
+import com.hypherionmc.craterlib.core.networking.data.PacketContext;
+import com.hypherionmc.craterlib.core.networking.data.PacketHolder;
+import com.hypherionmc.craterlib.core.networking.data.PacketSide;
+import com.hypherionmc.craterlib.nojang.network.BridgedFriendlyByteBuf;
+import com.hypherionmc.craterlib.nojang.resources.ResourceIdentifier;
+
+import java.util.HashMap;
+import java.util.Map;
+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 class DeferredPacketRegistrar implements PacketRegistrar {
+
+    private static final Map<Class<?>, PacketHolder<?>> QUEUED_PACKET_MAP = new HashMap<>();
+
+    @Override
+    public PacketSide side() {
+        return PacketSide.CLIENT;
+    }
+
+    @Override
+    public <T> PacketRegistrar registerPacket(ResourceIdentifier packetIdentifier, Class<T> messageType, BiConsumer<T, BridgedFriendlyByteBuf> encoder, Function<BridgedFriendlyByteBuf, T> decoder, Consumer<PacketContext<T>> handler) {
+        PacketHolder<T> container = new PacketHolder<>(packetIdentifier, messageType, encoder, decoder, handler);
+        QUEUED_PACKET_MAP.put(messageType, container);
+        return this;
+    }
+
+
+    public void registerQueuedPackets(PacketRegistry packetRegistration) {
+        if (!QUEUED_PACKET_MAP.isEmpty()) {
+            packetRegistration.PACKET_MAP.putAll(QUEUED_PACKET_MAP);
+            QUEUED_PACKET_MAP.forEach((aClass, container) -> packetRegistration.registerPacket(container));
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+package com.hypherionmc.craterlib.core.networking;
+
+import com.hypherionmc.craterlib.core.networking.data.PacketContext;
+import com.hypherionmc.craterlib.core.networking.data.PacketSide;
+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 interface PacketRegistrar {
+
+    PacketSide side();
+
+    <T> PacketRegistrar registerPacket(ResourceIdentifier id, 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/networking/PacketRegistry.java

@@ -0,0 +1,41 @@
+package com.hypherionmc.craterlib.core.networking;
+
+import com.hypherionmc.craterlib.api.networking.CraterNetworkHandler;
+import com.hypherionmc.craterlib.core.networking.data.PacketContext;
+import com.hypherionmc.craterlib.core.networking.data.PacketHolder;
+import com.hypherionmc.craterlib.core.networking.data.PacketSide;
+import com.hypherionmc.craterlib.nojang.network.BridgedFriendlyByteBuf;
+import com.hypherionmc.craterlib.nojang.resources.ResourceIdentifier;
+
+import java.util.HashMap;
+import java.util.Map;
+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 abstract class PacketRegistry implements CraterNetworkHandler, PacketRegistrar {
+
+    protected final Map<Class<?>, PacketHolder<?>> PACKET_MAP = new HashMap<>();
+
+    protected final PacketSide side;
+
+    public PacketRegistry(PacketSide side) {
+        this.side = side;
+    }
+
+    public <T> PacketRegistrar registerPacket(ResourceIdentifier id, Class<T> messageType, BiConsumer<T, BridgedFriendlyByteBuf> encoder, Function<BridgedFriendlyByteBuf, T> decoder, Consumer<PacketContext<T>> handler) {
+        PacketHolder<T> holder = new PacketHolder<>(id, messageType, encoder, decoder, handler);
+        PACKET_MAP.put(messageType, holder);
+        registerPacket(holder);
+        return this;
+    }
+
+    public PacketSide side() {
+        return side;
+    }
+
+    protected abstract <T> void registerPacket(PacketHolder<T> packetHolder);
+}

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

@@ -0,0 +1,15 @@
+package com.hypherionmc.craterlib.core.networking.data;
+
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Based on https://github.com/mysticdrew/common-networking/tree/1.20.4
+ */
+public record PacketContext<T>(@Nullable BridgedPlayer sender, T message, PacketSide side) {
+
+    public PacketContext(T message, PacketSide side) {
+        this(null, message, side);
+    }
+
+}

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/networking/data/PacketSide.java

@@ -0,0 +1,13 @@
+package com.hypherionmc.craterlib.core.networking.data;
+
+public enum PacketSide {
+    CLIENT,
+    SERVER;
+
+    public PacketSide flipped() {
+        if (CLIENT.equals(this))
+            return SERVER;
+
+        return CLIENT;
+    }
+}

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

@@ -0,0 +1,23 @@
+package com.hypherionmc.craterlib.core.platform;
+
+import com.hypherionmc.craterlib.nojang.client.BridgedMinecraft;
+import com.hypherionmc.craterlib.nojang.client.multiplayer.BridgedClientLevel;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import com.hypherionmc.craterlib.utils.InternalServiceUtil;
+import net.minecraft.network.Connection;
+
+/**
+ * @author HypherionSA
+ */
+public interface ClientPlatform {
+
+    public final ClientPlatform INSTANCE = InternalServiceUtil.load(ClientPlatform.class);
+
+    BridgedMinecraft getClientInstance();
+
+    BridgedPlayer getClientPlayer();
+
+    BridgedClientLevel getClientLevel();
+
+    Connection getClientConnection();
+}

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

@@ -0,0 +1,15 @@
+package com.hypherionmc.craterlib.core.platform;
+
+import com.hypherionmc.craterlib.nojang.server.BridgedMinecraftServer;
+import com.hypherionmc.craterlib.utils.InternalServiceUtil;
+
+/**
+ * @author HypherionSA
+ */
+public interface CommonPlatform {
+
+    public CommonPlatform INSTANCE = InternalServiceUtil.load(CommonPlatform.class);
+
+    BridgedMinecraftServer getMCServer();
+
+}

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

@@ -0,0 +1,13 @@
+package com.hypherionmc.craterlib.core.platform;
+
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import com.hypherionmc.craterlib.utils.InternalServiceUtil;
+
+public interface CompatUtils {
+
+    public static final CompatUtils INSTANCE = InternalServiceUtil.load(CompatUtils.class);
+
+    boolean isPlayerActive(BridgedPlayer player);
+    String getSkinUUID(BridgedPlayer player);
+
+}

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

@@ -0,0 +1,18 @@
+package com.hypherionmc.craterlib.core.platform;
+
+/**
+ * @author HypherionSA
+ */
+public enum Environment {
+    CLIENT,
+    SERVER,
+    UNKNOWN;
+
+    public boolean isClient() {
+        return this == CLIENT;
+    }
+
+    public boolean isServer() {
+        return this == SERVER;
+    }
+}

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

@@ -0,0 +1,32 @@
+package com.hypherionmc.craterlib.core.platform;
+
+import com.hypherionmc.craterlib.utils.InternalServiceUtil;
+
+import java.io.File;
+
+/**
+ * @author HypherionSA
+ * Helper class to provide information about the ModLoader
+ */
+public interface ModloaderEnvironment {
+
+    public final ModloaderEnvironment INSTANCE = InternalServiceUtil.load(ModloaderEnvironment.class);
+
+    boolean isFabric();
+
+    String getGameVersion();
+
+    File getGameFolder();
+
+    File getConfigFolder();
+
+    File getModsFolder();
+
+    Environment getEnvironment();
+
+    boolean isModLoaded(String modid);
+
+    boolean isDevEnv();
+
+    int getModCount();
+}

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

@@ -0,0 +1,90 @@
+package com.hypherionmc.craterlib.core.rpcsdk;
+
+import com.hypherionmc.craterlib.core.rpcsdk.callbacks.*;
+import com.sun.jna.Structure;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author HypherionSA
+ * Class containing references to all available discord event handles.
+ * Registering a handler is optional, and non-assigned handlers will be ignored
+ */
+public class DiscordEventHandlers extends Structure {
+
+    // Callback for when the RPC was initialized successfully
+    public ReadyCallback ready;
+
+    // Callback for when the Discord connection was ended
+    public DisconnectedCallback disconnected;
+
+    // Callback for when a Discord Error occurs
+    public ErroredCallback errored;
+
+    // Callback for when a player joins the game
+    public JoinGameCallback joinGame;
+
+    // Callback for when a player spectates the game
+    public SpectateGameCallback spectateGame;
+
+    // Callback for when a players request to join your game
+    public JoinRequestCallback joinRequest;
+
+    /**
+     * DO NOT TOUCH THIS... EVER!
+     */
+    @Override
+    protected List<String> getFieldOrder() {
+        return Arrays.asList(
+                "ready",
+                "disconnected",
+                "errored",
+                "joinGame",
+                "spectateGame",
+                "joinRequest"
+        );
+    }
+
+    public static class Builder {
+        private final DiscordEventHandlers handlers;
+
+        public Builder() {
+            this.handlers = new DiscordEventHandlers();
+        }
+
+        public Builder ready(ReadyCallback readyCallback) {
+            handlers.ready = readyCallback;
+            return this;
+        }
+
+        public Builder disconnected(DisconnectedCallback disconnectedCallback) {
+            handlers.disconnected = disconnectedCallback;
+            return this;
+        }
+
+        public Builder errored(ErroredCallback erroredCallback) {
+            handlers.errored = erroredCallback;
+            return this;
+        }
+
+        public Builder joinGame(JoinGameCallback joinGameCallback) {
+            handlers.joinGame = joinGameCallback;
+            return this;
+        }
+
+        public Builder spectateGame(SpectateGameCallback spectateGameCallback) {
+            handlers.spectateGame = spectateGameCallback;
+            return this;
+        }
+
+        public Builder joinRequest(JoinRequestCallback joinRequestCallback) {
+            handlers.joinRequest = joinRequestCallback;
+            return this;
+        }
+
+        public DiscordEventHandlers build() {
+            return handlers;
+        }
+    }
+}

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

@@ -0,0 +1,99 @@
+package com.hypherionmc.craterlib.core.rpcsdk;
+
+import com.sun.jna.Library;
+import com.sun.jna.Native;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * @author HypherionSA
+ * Java Wrapper of the Discord-RPC Library
+ */
+public interface DiscordRPC extends Library {
+
+    DiscordRPC INSTANCE = Native.load("discord-rpc", DiscordRPC.class);
+
+    /**
+     * Open a New RPC Connection
+     *
+     * @param applicationId The ID of the Application the RPC is tied to
+     * @param handlers      Optional Event Callback Handlers
+     * @param autoRegister  Auto Register the running game
+     * @param steamId       Steam ID of the game
+     */
+    void Discord_Initialize(@NotNull String applicationId, @Nullable DiscordEventHandlers handlers, boolean autoRegister, @Nullable String steamId);
+
+    /**
+     * Shutdown the RPC instance and disconnect from discord
+     */
+    void Discord_Shutdown();
+
+    /**
+     * Need to be called manually at least every 2 seconds, to allow RPC updates
+     * and callback handlers to fire
+     */
+    void Discord_RunCallbacks();
+
+    /**
+     * Not sure about this. Believe it needs to be called manually in some circumstances
+     */
+    void Discord_UpdateConnection();
+
+    /**
+     * Update the Rich Presence
+     *
+     * @param struct Constructed {@link DiscordRichPresence}
+     */
+    void Discord_UpdatePresence(@Nullable DiscordRichPresence struct);
+
+    /**
+     * Clear the current Rich Presence
+     */
+    void Discord_ClearPresence();
+
+    /**
+     * Respond to Join/Spectate callback
+     *
+     * @param userid The Discord User ID of the user that initiated the request
+     * @param reply  Reply to the request. See {@link DiscordReply}
+     */
+    void Discord_Respond(@NotNull String userid, int reply);
+
+    /**
+     * Replace the already registered {@link DiscordEventHandlers}
+     *
+     * @param handlers The new handlers to apply
+     */
+    void Discord_UpdateHandlers(@Nullable DiscordEventHandlers handlers);
+
+    /**
+     * Register the executable of the application/game
+     * Only applicable when autoRegister is set to false
+     *
+     * @param applicationId The Application ID
+     * @param command       The Launch command of the game
+     *                      <p>
+     *                      NB: THIS DOES NOT WORK WITH MINECRAFT
+     */
+    void Discord_Register(String applicationId, String command);
+
+    /**
+     * Register the Steam executable of the application/game
+     *
+     * @param applicationId The Application ID
+     * @param steamId       The Steam ID of the application/game
+     */
+    void Discord_RegisterSteamGame(String applicationId, String steamId);
+
+    public enum DiscordReply {
+        NO(0),
+        YES(1),
+        IGNORE(2);
+
+        public final int reply;
+
+        DiscordReply(int reply) {
+            this.reply = reply;
+        }
+    }
+}

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

@@ -0,0 +1,248 @@
+package com.hypherionmc.craterlib.core.rpcsdk;
+
+import com.hypherionmc.craterlib.core.rpcsdk.helpers.RPCButton;
+import com.sun.jna.Structure;
+import org.jetbrains.annotations.NotNull;
+
+import java.time.OffsetDateTime;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author HypherionSA
+ * Class reprenting a Discord RPC activity
+ */
+public class DiscordRichPresence extends Structure {
+
+    // First line of text on the RPC
+    public String state;
+
+    // Second line of text on the RPC
+    public String details;
+
+    // Time the activity started in UNIX-Timestamp format
+    public long startTimestamp;
+
+    // Time the activity will end in UNIX-Timestamp format
+    public long endTimestamp;
+
+    // URL or Asset key of the Large Image
+    public String largeImageKey;
+
+    // Hover text to display when hovering the Large Image
+    public String largeImageText;
+
+    // URL or Asset key of the Small Image
+    public String smallImageKey;
+
+    // Hover text to display when hovering the Small Image
+    public String smallImageText;
+
+    // Id of the player's party, lobby, or group.
+    public String partyId;
+
+    // Current size of the player's party, lobby, or group.
+    public int partySize;
+
+    // Maximum size of the player's party, lobby, or group.
+    public int partyMax;
+
+    // Unused
+    public String partyPrivacy;
+
+    // Unused.
+    public String matchSecret;
+
+    // Unique hashed string for chat invitations and Ask to Join.
+    public String joinSecret;
+
+    // Unique hashed string for Spectate button.
+    public String spectateSecret;
+
+    // Label of the First RPC Button
+    public String button_label_1;
+
+    // URL of the First RPC Button
+    public String button_url_1;
+
+    // Label of the Second RPC Button
+    public String button_label_2;
+
+    // URL of the Second RPC Button
+    public String button_url_2;
+
+    // Unused
+    public int instance;
+
+    public DiscordRichPresence() {
+        setStringEncoding("UTF-8");
+    }
+
+    /**
+     * DO NOT TOUCH THIS... EVER!
+     */
+    @Override
+    protected List<String> getFieldOrder() {
+        return Arrays.asList(
+                "state",
+                "details",
+                "startTimestamp",
+                "endTimestamp",
+                "largeImageKey",
+                "largeImageText",
+                "smallImageKey",
+                "smallImageText",
+                "partyId",
+                "partySize",
+                "partyMax",
+                "partyPrivacy",
+                "matchSecret",
+                "joinSecret",
+                "spectateSecret",
+                "button_label_1",
+                "button_url_1",
+                "button_label_2",
+                "button_url_2",
+                "instance"
+        );
+    }
+
+    public static class Builder {
+        private final DiscordRichPresence rpc;
+
+        public Builder(String state) {
+            rpc = new DiscordRichPresence();
+
+            if (state != null && !state.isEmpty()) {
+                rpc.state = state.substring(0, Math.min(state.length(), 128));
+            }
+        }
+
+        public Builder setDetails(String details) {
+            if (details != null && !details.isEmpty()) {
+                rpc.details = details.substring(0, Math.min(details.length(), 128));
+            }
+            return this;
+        }
+
+        public Builder setStartTimestamp(long timestamp) {
+            rpc.startTimestamp = timestamp;
+            return this;
+        }
+
+        public Builder setStartTimestamp(OffsetDateTime timestamp) {
+            rpc.startTimestamp = timestamp.toEpochSecond();
+            return this;
+        }
+
+        public Builder setEndTimestamp(long timestamp) {
+            rpc.endTimestamp = timestamp;
+            return this;
+        }
+
+        public Builder setEndTimestamp(OffsetDateTime timestamp) {
+            rpc.endTimestamp = timestamp.toEpochSecond();
+            return this;
+        }
+
+        public Builder setLargeImage(String key) {
+            return this.setLargeImage(key, "");
+        }
+
+        public Builder setLargeImage(@NotNull String key, String text) {
+            // Null check used for users blatantly ignoring the NotNull marker
+            if ((text != null && !text.isEmpty()) && key != null) {
+                throw new IllegalArgumentException("Image key cannot be null when assigning a hover text");
+            }
+
+            rpc.largeImageKey = key;
+            rpc.largeImageText = text;
+            return this;
+        }
+
+        public Builder setSmallImage(String key) {
+            return this.setSmallImage(key, "");
+        }
+
+        public Builder setSmallImage(@NotNull String key, String text) {
+            // Null check used for users blatantly ignoring the NotNull marker
+            if ((text != null && !text.isEmpty()) && key != null) {
+                throw new IllegalArgumentException("Image key cannot be null when assigning a hover text");
+            }
+
+            rpc.smallImageKey = key;
+            rpc.smallImageText = text;
+            return this;
+        }
+
+        public Builder setParty(String party, int size, int max) {
+            // Buttons are present, ignore
+            if ((rpc.button_label_1 != null && rpc.button_label_1.isEmpty()) || (rpc.button_label_2 != null && rpc.button_label_2.isEmpty()))
+                return this;
+
+            rpc.partyId = party;
+            rpc.partySize = size;
+            rpc.partyMax = max;
+            return this;
+        }
+
+        public Builder setSecrets(String match, String join, String spectate) {
+            // Buttons are present, ignore
+            if ((rpc.button_label_1 != null && rpc.button_label_1.isEmpty()) || (rpc.button_label_2 != null && rpc.button_label_2.isEmpty()))
+                return this;
+
+            rpc.matchSecret = match;
+            rpc.joinSecret = join;
+            rpc.spectateSecret = spectate;
+            return this;
+        }
+
+        public Builder setSecrets(String join, String spectate) {
+            // Buttons are present, ignore
+            if ((rpc.button_label_1 != null && rpc.button_label_1.isEmpty()) || (rpc.button_label_2 != null && rpc.button_label_2.isEmpty()))
+                return this;
+
+            rpc.joinSecret = join;
+            rpc.spectateSecret = spectate;
+            return this;
+        }
+
+        public Builder setInstance(boolean i) {
+            // Buttons are present, ignore
+            if ((rpc.button_label_1 != null && rpc.button_label_1.isEmpty()) || (rpc.button_label_2 != null && rpc.button_label_2.isEmpty()))
+                return this;
+
+            rpc.instance = i ? 1 : 0;
+            return this;
+        }
+
+        public Builder setButtons(RPCButton button) {
+            return this.setButtons(Collections.singletonList(button));
+        }
+
+        public Builder setButtons(RPCButton button1, RPCButton button2) {
+            return this.setButtons(Arrays.asList(button1, button2));
+        }
+
+        public Builder setButtons(List<RPCButton> rpcButtons) {
+            // Limit to 2 Buttons. Discord Limitation
+            if (rpcButtons != null && !rpcButtons.isEmpty()) {
+                int length = Math.min(rpcButtons.size(), 2);
+                rpc.button_label_1 = rpcButtons.get(0).getLabel();
+                rpc.button_url_1 = rpcButtons.get(0).getUrl();
+
+                if (length == 2) {
+                    rpc.button_label_2 = rpcButtons.get(1).getLabel();
+                    rpc.button_url_2 = rpcButtons.get(1).getUrl();
+                }
+            }
+
+            return this;
+        }
+
+        public DiscordRichPresence build() {
+            return rpc;
+        }
+    }
+}

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

@@ -0,0 +1,39 @@
+package com.hypherionmc.craterlib.core.rpcsdk;
+
+import com.sun.jna.Structure;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author HypherionSA
+ * Class representing the Discord User
+ */
+public class DiscordUser extends Structure {
+
+    // The User ID of the User
+    public String userId;
+
+    // The Username of the User
+    public String username;
+
+    // The unique identifier of the user. Discontinued by Discord
+    @Deprecated
+    public String discriminator;
+
+    // The avatar has of the user
+    public String avatar;
+
+    /**
+     * DO NOT TOUCH THIS... EVER!
+     */
+    @Override
+    protected List<String> getFieldOrder() {
+        return Arrays.asList(
+                "userId",
+                "username",
+                "discriminator",
+                "avatar"
+        );
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.hypherionmc.craterlib.core.rpcsdk.callbacks;
+
+import com.sun.jna.Callback;
+
+/**
+ * @author HypherionSA
+ * Callback for when the Discord RPC disconnects
+ */
+public interface DisconnectedCallback extends Callback {
+
+    /**
+     * Called when RPC disconnected
+     *
+     * @param errorCode Error code if any
+     * @param message   Details about the disconnection
+     */
+    void apply(int errorCode, String message);
+}

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

@@ -0,0 +1,18 @@
+package com.hypherionmc.craterlib.core.rpcsdk.callbacks;
+
+import com.sun.jna.Callback;
+
+/**
+ * @author HypherionSA
+ * Callback for when the RPC ran into an error
+ */
+public interface ErroredCallback extends Callback {
+
+    /**
+     * Called when an RPC error occurs
+     *
+     * @param errorCode Error code if any
+     * @param message   Details about the error
+     */
+    void apply(int errorCode, String message);
+}

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

@@ -0,0 +1,17 @@
+package com.hypherionmc.craterlib.core.rpcsdk.callbacks;
+
+import com.sun.jna.Callback;
+
+/**
+ * @author HypherionSA
+ * Callback for when someone was approved to join your game
+ */
+public interface JoinGameCallback extends Callback {
+
+    /**
+     * Called when someone joins a game from {@link JoinRequestCallback}
+     *
+     * @param joinSecret Secret or Password required to let the player join the game
+     */
+    void apply(String joinSecret);
+}

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

@@ -0,0 +1,19 @@
+package com.hypherionmc.craterlib.core.rpcsdk.callbacks;
+
+import com.hypherionmc.craterlib.core.rpcsdk.DiscordUser;
+import com.sun.jna.Callback;
+
+/**
+ * @author HypherionSA
+ * Callback for when someone requests to join your game
+ */
+public interface JoinRequestCallback extends Callback {
+
+    /**
+     * Called when someone clicks on the Join Game button
+     *
+     * @param user The Discord User trying to join your game
+     * @see DiscordUser
+     */
+    void apply(DiscordUser user);
+}

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

@@ -0,0 +1,19 @@
+package com.hypherionmc.craterlib.core.rpcsdk.callbacks;
+
+import com.hypherionmc.craterlib.core.rpcsdk.DiscordUser;
+import com.sun.jna.Callback;
+
+/**
+ * @author HypherionSA
+ * Callback for when the RPC has connected successfully
+ */
+public interface ReadyCallback extends Callback {
+
+    /**
+     * Called when the RPC is connected and ready to be used
+     *
+     * @param user The user the RPC is displayed on
+     * @see DiscordUser
+     */
+    void apply(DiscordUser user);
+}

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

@@ -0,0 +1,17 @@
+package com.hypherionmc.craterlib.core.rpcsdk.callbacks;
+
+import com.sun.jna.Callback;
+
+/**
+ * @author HypherionSA
+ * Callback for when someone is requesting to spectate your game
+ */
+public interface SpectateGameCallback extends Callback {
+
+    /**
+     * Called when joining the game
+     *
+     * @param spectateSecret Secret or Password required to let the player spectate
+     */
+    void apply(String spectateSecret);
+}

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

@@ -0,0 +1,55 @@
+package com.hypherionmc.craterlib.core.rpcsdk.helpers;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.io.Serializable;
+
+/**
+ * @author HypherionSA
+ * Helper class to add Buttons to Discord Rich Presence
+ * This can not be used with Join/Spectate
+ */
+public class RPCButton implements Serializable {
+
+    // The label of the button
+    private final String label;
+
+    // The URL the button will open when clicked
+    private final String url;
+
+    protected RPCButton(String label, String url) {
+        this.label = label;
+        this.url = url;
+    }
+
+    /**
+     * Create a new RPC Button
+     *
+     * @param label The label of the button
+     * @param url   The URL the button will open when clicked
+     * @return The constructed button
+     */
+    public static RPCButton create(@NotNull String label, @NotNull String url) {
+        // Null check used here for users blatantly ignoring the NotNull marker
+        if (label == null || label.isEmpty() || url == null || url.isEmpty()) {
+            throw new IllegalArgumentException("RPC Buttons require both a label and url");
+        }
+
+        label = label.substring(0, Math.min(label.length(), 31));
+        return new RPCButton(label, url);
+    }
+
+    /**
+     * @return The label assigned to the button
+     */
+    public String getLabel() {
+        return label;
+    }
+
+    /**
+     * @return The URL of the button
+     */
+    public String getUrl() {
+        return url;
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/mixin/ChatInputSuggestorMixin.java

@@ -0,0 +1,84 @@
+package com.hypherionmc.craterlib.mixin;
+
+import com.hypherionmc.craterlib.client.mentions.MentionsController;
+import net.minecraft.client.gui.components.CommandSuggestions;
+import net.minecraft.client.gui.components.EditBox;
+import org.objectweb.asm.Opcodes;
+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.ModifyVariable;
+import org.spongepowered.asm.mixin.injection.Slice;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+/**
+ * @author HypherionSA
+ * Allow Users, Roles and Channels to be pingable from MC chat (Client Side)
+ */
+@Mixin(CommandSuggestions.class)
+public abstract class ChatInputSuggestorMixin {
+
+    @Shadow
+    public abstract void showSuggestions(boolean p_93931_);
+
+    @Shadow @Final
+    EditBox input;
+
+    @Shadow
+    private static int getLastWordIndex(String p_93913_) {
+        return 0;
+    }
+
+    @Inject(
+            method = "updateCommandInfo",
+            at = @At(
+                    value = "FIELD",
+                    target = "Lnet/minecraft/client/gui/components/CommandSuggestions;pendingSuggestions:Ljava/util/concurrent/CompletableFuture;",
+                    opcode = Opcodes.PUTFIELD,
+                    shift = At.Shift.AFTER,
+                    ordinal = 0
+            ),
+            slice = @Slice(
+                from = @At(
+                        value = "INVOKE",
+                        target = "Lnet/minecraft/client/gui/components/CommandSuggestions;getLastWordIndex(Ljava/lang/String;)I"
+                )
+            )
+    )
+    private void injectSuggestions(CallbackInfo ci) {
+        if (MentionsController.hasMentions() && MentionsController.isLastMentionConditional()) {
+            this.showSuggestions(true);
+        }
+    }
+
+    @SuppressWarnings("InvalidInjectorMethodSignature")
+    @ModifyVariable(method = "updateCommandInfo", at = @At(value = "STORE"), ordinal = 0, name = "collection")
+    private Collection<String> injectMentions(Collection<String> vanilla) {
+        if (!MentionsController.hasMentions())
+            return vanilla;
+
+        ArrayList<String> newSuggest = new ArrayList<>(vanilla);
+
+        String currentInput = this.input.getValue();
+        int currentCursorPosition = this.input.getCursorPosition();
+
+        String textBeforeCursor = currentInput.substring(0, currentCursorPosition);
+        int startOfCurrentWord = getLastWordIndex(textBeforeCursor);
+
+        String currentWord = textBeforeCursor.substring(startOfCurrentWord);
+        String finalWord = currentWord.replace("[", "").replace("]", "");
+
+        Collection<String> mentions = MentionsController.getMentions(finalWord);
+
+        if (!mentions.isEmpty()) {
+            mentions.forEach(m -> newSuggest.add("[" + m + "]"));
+        }
+
+        return newSuggest;
+    }
+}

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()));
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+package com.hypherionmc.craterlib.mixin.events;
+
+import com.hypherionmc.craterlib.api.events.common.CraterPlayerDeathEvent;
+import com.hypherionmc.craterlib.core.event.CraterEventBus;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.entity.player.Player;
+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;
+
+@Mixin(Player.class)
+public class PlayerMixin {
+
+    @Inject(method = "die", at = @At("HEAD"))
+    private void injectPlayerDeathEvent(DamageSource damageSource, CallbackInfo ci) {
+        CraterEventBus.INSTANCE.postEvent(new CraterPlayerDeathEvent(BridgedPlayer.of(((Player) (Object) this)), damageSource));
+    }
+
+}

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

@@ -0,0 +1,21 @@
+package com.hypherionmc.craterlib.mixin.events;
+
+import com.hypherionmc.craterlib.api.events.common.CraterPlayerDeathEvent;
+import com.hypherionmc.craterlib.core.event.CraterEventBus;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.damagesource.DamageSource;
+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;
+
+@Mixin(ServerPlayer.class)
+public class ServerPlayerMixin {
+
+    @Inject(method = "die", at = @At("HEAD"))
+    private void injectPlayerDeathEvent(DamageSource damageSource, CallbackInfo ci) {
+        CraterEventBus.INSTANCE.postEvent(new CraterPlayerDeathEvent(BridgedPlayer.of(((ServerPlayer) (Object) this)), damageSource));
+    }
+
+}

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

@@ -0,0 +1,25 @@
+package com.hypherionmc.craterlib.mixin.events.client;
+
+import com.hypherionmc.craterlib.api.events.client.CraterSinglePlayerEvent;
+import com.hypherionmc.craterlib.core.event.CraterEventBus;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+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;
+
+@Mixin(ClientLevel.class)
+public class ClientLevelMixin {
+
+    @Inject(method = "addEntity", at = @At("HEAD"))
+    private void injectSinglePlayerJoinEvent(int i, Entity entity, CallbackInfo ci) {
+        if (entity instanceof Player player) {
+            CraterSinglePlayerEvent.PlayerLogin playerLogin = new CraterSinglePlayerEvent.PlayerLogin(BridgedPlayer.of(player));
+            CraterEventBus.INSTANCE.postEvent(playerLogin);
+        }
+    }
+
+}

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

@@ -0,0 +1,31 @@
+package com.hypherionmc.craterlib.mixin.events.client;
+
+import com.hypherionmc.craterlib.api.events.client.ScreenEvent;
+import com.hypherionmc.craterlib.core.event.CraterEventBus;
+import com.hypherionmc.craterlib.nojang.client.gui.BridgedScreen;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.screens.Screen;
+import org.jetbrains.annotations.Nullable;
+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.CallbackInfo;
+
+@Mixin(Minecraft.class)
+public class MinecraftMixin {
+
+    @Shadow
+    @Nullable
+    public Screen screen;
+
+    @Inject(method = "setScreen", at = @At(value = "TAIL"))
+    private void injectScreenOpeningEvent(Screen screen, CallbackInfo ci) {
+        Screen old = this.screen;
+        if (screen != null) {
+            ScreenEvent.Opening opening = new ScreenEvent.Opening(BridgedScreen.of(old), BridgedScreen.of(screen));
+            CraterEventBus.INSTANCE.postEvent(opening);
+        }
+    }
+
+}

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

@@ -0,0 +1,23 @@
+package com.hypherionmc.craterlib.mixin.events.client;
+
+import com.hypherionmc.craterlib.api.events.client.PlayerJoinRealmEvent;
+import com.hypherionmc.craterlib.core.event.CraterEventBus;
+import com.hypherionmc.craterlib.nojang.realmsclient.dto.BridgedRealmsServer;
+import com.mojang.realmsclient.RealmsMainScreen;
+import com.mojang.realmsclient.dto.RealmsServer;
+import net.minecraft.client.gui.screens.Screen;
+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;
+
+@Mixin(RealmsMainScreen.class)
+public class RealmsMainScreenMixin {
+
+    @Inject(at = @At("HEAD"), method = "play")
+    private void play(RealmsServer serverData, Screen arg2, CallbackInfo ci) {
+        PlayerJoinRealmEvent playerJoinRealm = new PlayerJoinRealmEvent(BridgedRealmsServer.of(serverData));
+        CraterEventBus.INSTANCE.postEvent(playerJoinRealm);
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/advancements/BridgedAdvancement.java

@@ -0,0 +1,21 @@
+package com.hypherionmc.craterlib.nojang.advancements;
+
+import lombok.RequiredArgsConstructor;
+import net.minecraft.advancements.Advancement;
+
+import java.util.Optional;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedAdvancement {
+
+    private final Advancement internal;
+
+    public Optional<BridgedDisplayInfo> displayInfo() {
+        if (internal.getDisplay() != null) {
+            return Optional.of(BridgedDisplayInfo.of(internal.getDisplay()));
+        }
+
+        return Optional.empty();
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/advancements/BridgedDisplayInfo.java

@@ -0,0 +1,29 @@
+package com.hypherionmc.craterlib.nojang.advancements;
+
+import com.hypherionmc.craterlib.utils.ChatUtils;
+import lombok.RequiredArgsConstructor;
+import net.kyori.adventure.text.Component;
+import net.minecraft.advancements.DisplayInfo;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedDisplayInfo {
+
+    private final DisplayInfo internal;
+
+    public boolean shouldDisplay() {
+        return internal.shouldAnnounceChat();
+    }
+
+    public boolean isHidden() {
+        return internal.isHidden();
+    }
+
+    public Component displayName() {
+        return ChatUtils.mojangToAdventure(internal.getTitle());
+    }
+
+    public Component description() {
+        return ChatUtils.mojangToAdventure(internal.getDescription());
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/authlib/BridgedGameProfile.java

@@ -0,0 +1,29 @@
+package com.hypherionmc.craterlib.nojang.authlib;
+
+import com.mojang.authlib.GameProfile;
+import lombok.RequiredArgsConstructor;
+
+import java.util.UUID;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedGameProfile {
+
+    private final GameProfile internal;
+
+    public static BridgedGameProfile mojang(UUID id, String name) {
+        return new BridgedGameProfile(new GameProfile(id, name));
+    }
+
+    public String getName() {
+        return internal.getName();
+    }
+
+    public UUID getId() {
+        return internal.getId();
+    }
+
+    public GameProfile toMojang() {
+        return internal;
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/client/BridgedMinecraft.java

@@ -0,0 +1,84 @@
+package com.hypherionmc.craterlib.nojang.client;
+
+import com.hypherionmc.craterlib.nojang.client.multiplayer.BridgedClientLevel;
+import com.hypherionmc.craterlib.nojang.client.multiplayer.BridgedServerData;
+import com.hypherionmc.craterlib.nojang.client.server.BridgedIntegratedServer;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import lombok.Getter;
+import net.minecraft.SharedConstants;
+import net.minecraft.client.Minecraft;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.util.UUID;
+
+public class BridgedMinecraft {
+
+    @Getter
+    private static final BridgedMinecraft instance = new BridgedMinecraft();
+    private final Minecraft internal = Minecraft.getInstance();
+
+    public File getGameDirectory() {
+        return internal.gameDirectory;
+    }
+
+    public BridgedOptions getOptions() {
+        return BridgedOptions.of(internal.options);
+    }
+
+    @Nullable
+    public BridgedClientLevel getLevel() {
+        if (internal.level == null)
+            return null;
+
+        return BridgedClientLevel.of(internal.level);
+    }
+
+    public boolean isRealmServer() {
+        return internal.getCurrentServer() != null && internal.isConnectedToRealms();
+    }
+
+    public boolean isSinglePlayer() {
+        return internal.hasSingleplayerServer();
+    }
+
+    @Nullable
+    public BridgedPlayer getPlayer() {
+        if (internal.player == null)
+            return null;
+
+        return BridgedPlayer.of(internal.player);
+    }
+
+    public String getGameVersion() {
+        return SharedConstants.getCurrentVersion().getName();
+    }
+
+    public String getUserName() {
+        return internal.getUser().getName();
+    }
+
+    public UUID getPlayerId() {
+        return internal.getUser().getGameProfile().getId();
+    }
+
+    @Nullable
+    public BridgedServerData getCurrentServer() {
+        if (internal.getCurrentServer() == null)
+            return null;
+
+        return BridgedServerData.of(internal.getCurrentServer());
+    }
+
+    @Nullable
+    public BridgedIntegratedServer getSinglePlayerServer() {
+        return BridgedIntegratedServer.of(internal.getSingleplayerServer());
+    }
+
+    public int getServerPlayerCount () {
+        if (internal.getConnection() == null)
+            return 0;
+
+        return internal.getConnection().getOnlinePlayers().size();
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/client/BridgedOptions.java

@@ -0,0 +1,15 @@
+package com.hypherionmc.craterlib.nojang.client;
+
+import lombok.RequiredArgsConstructor;
+import net.minecraft.client.Options;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedOptions {
+
+    private final Options internal;
+
+    public String getLanguage() {
+        return internal.languageCode;
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/client/gui/BridgedScreen.java

@@ -0,0 +1,36 @@
+package com.hypherionmc.craterlib.nojang.client.gui;
+
+import lombok.RequiredArgsConstructor;
+import net.minecraft.client.gui.screens.LevelLoadingScreen;
+import net.minecraft.client.gui.screens.ReceivingLevelScreen;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.TitleScreen;
+import net.minecraft.client.gui.screens.multiplayer.JoinMultiplayerScreen;
+import net.minecraft.realms.RealmsScreen;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedScreen {
+
+    private final Screen internal;
+
+    public boolean isTitleScreen() {
+        return internal instanceof TitleScreen;
+    }
+
+    public boolean isRealmsScreen() {
+        return internal instanceof RealmsScreen;
+    }
+
+    public boolean isServerBrowserScreen() {
+        return internal instanceof JoinMultiplayerScreen;
+    }
+
+    public boolean isLoadingScreen() {
+        return internal instanceof LevelLoadingScreen || internal instanceof ReceivingLevelScreen;
+    }
+
+    public Screen toMojang() {
+        return internal;
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/client/multiplayer/BridgedClientLevel.java

@@ -0,0 +1,59 @@
+package com.hypherionmc.craterlib.nojang.client.multiplayer;
+
+import com.hypherionmc.craterlib.nojang.core.BridgedBlockPos;
+import com.hypherionmc.craterlib.nojang.resources.ResourceIdentifier;
+import com.hypherionmc.craterlib.utils.ChatUtils;
+import lombok.RequiredArgsConstructor;
+import net.kyori.adventure.text.Component;
+import net.minecraft.client.multiplayer.ClientLevel;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedClientLevel {
+
+    private final ClientLevel internal;
+
+    public boolean isClientSide() {
+        return internal.isClientSide();
+    }
+
+    public long getGameTime() {
+        return internal.getGameTime();
+    }
+
+    public long getDayTime() {
+        return internal.getDayTime();
+    }
+
+    public long dayTime() {
+        return internal.dayTime();
+    }
+
+    public boolean isRaining() {
+        return internal.isRaining();
+    }
+
+    public boolean isThundering() {
+        return internal.isThundering();
+    }
+
+    @Nullable
+    public ResourceIdentifier getDimensionKey() {
+        return ResourceIdentifier.fromMojang(internal.dimension().location());
+    }
+
+    @Nullable
+    public ResourceIdentifier getBiomeIdentifier(BridgedBlockPos onPos) {
+        AtomicReference<ResourceIdentifier> identifier = new AtomicReference<>(null);
+        internal.getBiome(onPos.toMojang()).unwrap().ifLeft(b -> identifier.set(ResourceIdentifier.fromMojang(b.location())));
+        return identifier.get();
+    }
+
+    @Nullable
+    public Component getDifficulty() {
+        return ChatUtils.mojangToAdventure(internal.getDifficulty().getDisplayName());
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/client/multiplayer/BridgedServerData.java

@@ -0,0 +1,45 @@
+package com.hypherionmc.craterlib.nojang.client.multiplayer;
+
+import com.hypherionmc.craterlib.utils.ChatUtils;
+import lombok.RequiredArgsConstructor;
+import net.kyori.adventure.text.Component;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.multiplayer.ServerData;
+import net.minecraft.client.multiplayer.ServerStatusPinger;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedServerData {
+
+    private final ServerData internal;
+
+    public String name() {
+        return internal.name;
+    }
+
+    public String ip() {
+        return internal.ip;
+    }
+
+    public Component motd() {
+        return ChatUtils.mojangToAdventure(internal.motd);
+    }
+
+    public int getMaxPlayers() {
+        if (!internal.pinged || internal.status.getString() == null) {
+            try {
+                new ServerStatusPinger().pingServer(internal, () -> {});
+            } catch (Exception ignored) {}
+        }
+
+        try {
+            return Integer.parseInt(ChatFormatting.stripFormatting(internal.status.getString()).split("/")[1]);
+        } catch (Exception ignored) {}
+
+        return 0;
+    }
+
+    public ServerData toMojang() {
+        return internal;
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/client/server/BridgedIntegratedServer.java

@@ -0,0 +1,19 @@
+package com.hypherionmc.craterlib.nojang.client.server;
+
+import lombok.RequiredArgsConstructor;
+import net.minecraft.client.server.IntegratedServer;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedIntegratedServer {
+
+    private final IntegratedServer internal;
+
+    public String getLevelName() {
+        return internal.getWorldData().getLevelName();
+    }
+
+    public IntegratedServer toMojang() {
+        return internal;
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/commands/BridgedCommandSourceStack.java

@@ -0,0 +1,22 @@
+package com.hypherionmc.craterlib.nojang.commands;
+
+import com.hypherionmc.craterlib.utils.ChatUtils;
+import lombok.RequiredArgsConstructor;
+import net.kyori.adventure.text.Component;
+import net.minecraft.commands.CommandSourceStack;
+
+import java.util.function.Supplier;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedCommandSourceStack {
+
+    private final CommandSourceStack internal;
+
+    public void sendSuccess(Supplier<Component> supplier, boolean bl) {
+        internal.sendSuccess(ChatUtils.adventureToMojang(supplier.get()), bl);
+    }
+
+    public CommandSourceStack toMojang() {
+        return internal;
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/commands/BridgedFakePlayer.java

@@ -0,0 +1,56 @@
+package com.hypherionmc.craterlib.nojang.commands;
+
+import com.hypherionmc.craterlib.nojang.server.BridgedMinecraftServer;
+import com.hypherionmc.craterlib.utils.ChatUtils;
+import net.minecraft.commands.CommandSource;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TextComponent;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.phys.Vec2;
+import net.minecraft.world.phys.Vec3;
+
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public abstract class BridgedFakePlayer {
+
+    final MojangBridge internal;
+
+    public BridgedFakePlayer(BridgedMinecraftServer server, int perm, String name) {
+        internal = new MojangBridge(server.toMojang(), perm, name, this::onSuccess, this::onError);
+    }
+
+    public abstract void onSuccess(Supplier<net.kyori.adventure.text.Component> supplier, Boolean aBoolean);
+
+    public void onError(net.kyori.adventure.text.Component component) {
+        this.onSuccess(() -> component, false);
+    }
+
+    public CommandSourceStack toMojang() {
+        return internal;
+    }
+
+    static class MojangBridge extends CommandSourceStack {
+
+        private final BiConsumer<Supplier<net.kyori.adventure.text.Component>, Boolean> successCallback;
+        public final Consumer<net.kyori.adventure.text.Component> errorCallback;
+
+        MojangBridge(MinecraftServer server, int perm, String name, BiConsumer<Supplier<net.kyori.adventure.text.Component>, Boolean> successCallback, Consumer<net.kyori.adventure.text.Component> errorCallback) {
+            super(CommandSource.NULL, Vec3.ZERO, Vec2.ZERO, server.overworld(), perm, name, new TextComponent(name), server, null);
+            this.successCallback = successCallback;
+            this.errorCallback = errorCallback;
+        }
+
+        @Override
+        public void sendSuccess(Component supplier, boolean bl) {
+            successCallback.accept(() -> ChatUtils.mojangToAdventure(supplier), bl);
+        }
+
+        @Override
+        public void sendFailure(Component arg) {
+            errorCallback.accept(ChatUtils.mojangToAdventure(arg));
+        }
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/commands/CommandsRegistry.java

@@ -0,0 +1,85 @@
+package com.hypherionmc.craterlib.nojang.commands;
+
+import com.hypherionmc.craterlib.api.commands.CraterCommand;
+import com.hypherionmc.craterlib.nojang.authlib.BridgedGameProfile;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import com.hypherionmc.craterlib.utils.TriConsumer;
+import com.mojang.authlib.GameProfile;
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import net.minecraft.commands.arguments.GameProfileArgument;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class CommandsRegistry {
+
+    public static final CommandsRegistry INSTANCE = new CommandsRegistry();
+
+    private final List<CraterCommand> commands = new ArrayList<>();
+
+    public void registerCommand(CraterCommand cmd) {
+        commands.add(cmd);
+    }
+
+    public void registerCommands(CommandDispatcher<CommandSourceStack> stack) {
+        commands.forEach(cmd -> {
+            if (cmd.hasArguments()) {
+                CommandWithArguments.register(cmd, stack);
+            } else {
+                CommandWithoutArguments.register(cmd, stack);
+            }
+        });
+    }
+
+    static class CommandWithoutArguments {
+
+        public static void register(CraterCommand cmd, CommandDispatcher<CommandSourceStack> dispatcher) {
+            LiteralArgumentBuilder<CommandSourceStack> command = Commands.literal(cmd.getCommandName())
+                    .requires(source -> source.hasPermission(cmd.getPermissionLevel()))
+                            .executes(context -> {
+                               cmd.getExecutor().accept(BridgedCommandSourceStack.of(context.getSource()));
+                               return 1;
+                            });
+
+            dispatcher.register(command);
+        }
+
+    }
+
+    @SuppressWarnings("unchecked")
+    static class CommandWithArguments {
+
+        public static void register(CraterCommand cmd, CommandDispatcher<CommandSourceStack> dispatcher) {
+            LiteralArgumentBuilder<CommandSourceStack> command = Commands.literal(cmd.getCommandName())
+                    .requires(source -> source.hasPermission(cmd.getPermissionLevel()));
+
+            cmd.getArguments().forEach((key, pair) -> command.then(Commands.argument(key, pair.getLeft()).executes(context -> {
+
+                // This is FUCKING UGLY.... Need to improve this in the future
+                if (pair.getLeft() instanceof GameProfileArgument) {
+                    Collection<GameProfile> profiles = GameProfileArgument.getGameProfiles(context, key);
+                    List<BridgedGameProfile> bridgedGameProfiles = new ArrayList<>();
+
+                    profiles.forEach(p -> bridgedGameProfiles.add(BridgedGameProfile.of(p)));
+
+                    ((TriConsumer<BridgedPlayer, List<BridgedGameProfile>, BridgedCommandSourceStack>) pair.getRight())
+                            .accept(BridgedPlayer.of(context.getSource().getPlayerOrException()), bridgedGameProfiles, BridgedCommandSourceStack.of(context.getSource()));
+                    return 1;
+                }
+
+                return 1;
+            })));
+
+            dispatcher.register(command);
+        }
+
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/core/BridgedBlockPos.java

@@ -0,0 +1,27 @@
+package com.hypherionmc.craterlib.nojang.core;
+
+import lombok.RequiredArgsConstructor;
+import net.minecraft.core.BlockPos;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedBlockPos {
+
+    private final BlockPos internal;
+
+    public int getX() {
+        return internal.getX();
+    }
+
+    public int getY() {
+        return internal.getY();
+    }
+
+    public int getZ() {
+        return internal.getZ();
+    }
+
+    public BlockPos toMojang() {
+        return internal;
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/nbt/BridgedCompoundTag.java

@@ -0,0 +1,49 @@
+package com.hypherionmc.craterlib.nojang.nbt;
+
+import lombok.RequiredArgsConstructor;
+import net.minecraft.nbt.CompoundTag;
+
+import java.util.Set;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedCompoundTag {
+
+    private final CompoundTag internal;
+
+    public static BridgedCompoundTag empty() {
+        return new BridgedCompoundTag(new CompoundTag());
+    }
+
+    public BridgedCompoundTag getCompound(String key) {
+        return BridgedCompoundTag.of(internal.getCompound(key));
+    }
+
+    public Set<String> getAllKeys() {
+        return internal.getAllKeys();
+    }
+
+    public String getString(String key) {
+        return internal.getString(key);
+    }
+
+    public boolean getBoolean(String key) {
+        return internal.getBoolean(key);
+    }
+
+    public void putString(String key, String value) {
+        internal.putString(key, value);
+    }
+
+    public void put(String key, BridgedCompoundTag value) {
+        internal.put(key, value.toMojang());
+    }
+
+    public void putBoolean(String key, boolean value) {
+        internal.putBoolean(key, value);
+    }
+
+    public CompoundTag toMojang() {
+        return internal;
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/network/BridgedFriendlyByteBuf.java

@@ -0,0 +1,34 @@
+package com.hypherionmc.craterlib.nojang.network;
+
+import com.hypherionmc.craterlib.nojang.nbt.BridgedCompoundTag;
+import lombok.RequiredArgsConstructor;
+import net.minecraft.network.FriendlyByteBuf;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedFriendlyByteBuf {
+
+    private final FriendlyByteBuf internal;
+
+    public BridgedCompoundTag readNbt() {
+        return BridgedCompoundTag.of(internal.readNbt());
+    }
+
+    public BridgedFriendlyByteBuf writeNbt(BridgedCompoundTag tag) {
+        internal.writeNbt(tag.toMojang());
+        return BridgedFriendlyByteBuf.of(internal);
+    }
+
+    public BridgedFriendlyByteBuf writeUtf(String value) {
+        internal.writeUtf(value);
+        return BridgedFriendlyByteBuf.of(internal);
+    }
+
+    public String readUtf() {
+        return internal.readUtf();
+    }
+
+    public FriendlyByteBuf toMojang() {
+        return internal;
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/package-info.java

@@ -0,0 +1,9 @@
+/**
+ * @author HypherionSA
+ * This package, called NoJang, exposes various wrapped API's.
+ * Using this api, a mod can essentially run on ANY minecraft version this library
+ * supports, from one code base.
+ * IMPORTANT NOTE: THESE API'S MUST NEVER EXPOSE ANY MINECRAFT CLASSES OR CODE!!!!
+ * THEY MUST ALWAYS BE HANDLED INTERNALLY AND ONLY RETURN WRAPPED VARIANTS
+ */
+package com.hypherionmc.craterlib.nojang;

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/realmsclient/dto/BridgedRealmsServer.java

@@ -0,0 +1,40 @@
+package com.hypherionmc.craterlib.nojang.realmsclient.dto;
+
+import com.mojang.realmsclient.dto.PlayerInfo;
+import com.mojang.realmsclient.dto.RealmsServer;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedRealmsServer {
+
+    private final RealmsServer internal;
+
+    public String getName() {
+        return internal.getName();
+    }
+
+    public String getDescription() {
+        return internal.getDescription();
+    }
+
+    public String getWorldType() {
+        return internal.worldType.name();
+    }
+
+    public String getMinigameName() {
+        return internal.getMinigameName();
+    }
+
+    public String getMinigameImage() {
+        return internal.minigameImage;
+    }
+
+    public long getPlayerCount() {
+        return internal.players.stream().filter(PlayerInfo::getOnline).count();
+    }
+
+    public RealmsServer toMojang() {
+        return internal;
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/resources/ResourceIdentifier.java

@@ -0,0 +1,36 @@
+package com.hypherionmc.craterlib.nojang.resources;
+
+import net.minecraft.resources.ResourceLocation;
+
+public class ResourceIdentifier {
+
+    private final ResourceLocation internal;
+
+    public ResourceIdentifier(String namespace, String path) {
+        this.internal = new ResourceLocation(namespace, path);
+    }
+
+    public ResourceIdentifier(String path) {
+        this.internal = new ResourceLocation(path);
+    }
+
+    public String getNamespace() {
+        return internal.getNamespace();
+    }
+
+    public String getPath() {
+        return internal.getPath();
+    }
+
+    public String getString() {
+        return internal.toString();
+    }
+
+    public static ResourceIdentifier fromMojang(ResourceLocation location) {
+        return new ResourceIdentifier(location.getNamespace(), location.getPath());
+    }
+
+    public ResourceLocation toMojang() {
+        return internal;
+    }
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/server/BridgedMinecraftServer.java

@@ -0,0 +1,93 @@
+package com.hypherionmc.craterlib.nojang.server;
+
+import com.hypherionmc.craterlib.nojang.authlib.BridgedGameProfile;
+import com.hypherionmc.craterlib.nojang.commands.BridgedFakePlayer;
+import com.hypherionmc.craterlib.nojang.world.entity.player.BridgedPlayer;
+import com.hypherionmc.craterlib.utils.ChatUtils;
+import lombok.RequiredArgsConstructor;
+import net.kyori.adventure.text.Component;
+import net.minecraft.SharedConstants;
+import net.minecraft.Util;
+import net.minecraft.network.chat.ChatType;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.players.UserBanListEntry;
+import net.minecraft.server.players.UserWhiteListEntry;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedMinecraftServer {
+
+    private final MinecraftServer internal;
+
+    public boolean isUsingWhitelist() {
+        return internal.getPlayerList().isUsingWhitelist();
+    }
+
+    public int getPlayerCount() {
+        return internal.getPlayerList().getPlayerCount();
+    }
+
+    public int getMaxPlayers() {
+        return internal.getPlayerList().getMaxPlayers();
+    }
+
+    public String getServerModName() {
+        return internal.getServerModName();
+    }
+
+    public String getName() {
+        return SharedConstants.getCurrentVersion().getName();
+    }
+
+    public boolean usesAuthentication() {
+        return internal.usesAuthentication();
+    }
+
+    public void broadcastSystemMessage(Component text, boolean bl) {
+        internal.getPlayerList().broadcastMessage(ChatUtils.adventureToMojang(text), ChatType.SYSTEM, Util.NIL_UUID);
+    }
+
+    public boolean isPlayerBanned(BridgedGameProfile profile) {
+        return internal.getPlayerList().getBans().isBanned(profile.toMojang());
+    }
+
+    public void whitelistPlayer(BridgedGameProfile gameProfile) {
+        if (!internal.getPlayerList().isUsingWhitelist())
+            return;
+
+        internal.getPlayerList().getWhiteList().add(new UserWhiteListEntry(gameProfile.toMojang()));
+    }
+
+    public void unWhitelistPlayer(BridgedGameProfile gameProfile) {
+        if (!internal.getPlayerList().isUsingWhitelist())
+            return;
+
+        internal.getPlayerList().getWhiteList().remove(new UserWhiteListEntry(gameProfile.toMojang()));
+    }
+
+    public List<BridgedPlayer> getPlayers() {
+        List<BridgedPlayer> profiles = new ArrayList<>();
+
+        if (internal.getPlayerList() == null)
+            return profiles;
+
+        internal.getPlayerList().getPlayers().forEach(p -> profiles.add(BridgedPlayer.of(p)));
+
+        return profiles;
+    }
+
+    public void banPlayer(BridgedGameProfile profile) {
+        internal.getPlayerList().getBans().add(new UserBanListEntry(profile.toMojang()));
+    }
+
+    public void executeCommand(BridgedMinecraftServer server, BridgedFakePlayer player, String command) {
+        internal.getCommands().performCommand(player.toMojang(), command);
+    }
+
+    public MinecraftServer toMojang() {
+        return internal;
+    }
+
+}

1.18.2/Common/src/main/java/com/hypherionmc/craterlib/nojang/world/entity/player/BridgedPlayer.java

@@ -0,0 +1,63 @@
+package com.hypherionmc.craterlib.nojang.world.entity.player;
+
+import com.hypherionmc.craterlib.nojang.authlib.BridgedGameProfile;
+import com.hypherionmc.craterlib.nojang.core.BridgedBlockPos;
+import com.hypherionmc.craterlib.utils.ChatUtils;
+import lombok.RequiredArgsConstructor;
+import net.kyori.adventure.text.Component;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.network.ServerGamePacketListenerImpl;
+import net.minecraft.world.entity.player.Player;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+@RequiredArgsConstructor(staticName = "of")
+public class BridgedPlayer {
+
+    private final Player internal;
+
+    public Component getDisplayName() {
+        return ChatUtils.mojangToAdventure(internal.getDisplayName());
+    }
+
+    public Component getName() {
+        return ChatUtils.mojangToAdventure(internal.getName());
+    }
+
+    public UUID getUUID() {
+        return internal.getUUID();
+    }
+
+    public String getStringUUID() {
+        return internal.getStringUUID();
+    }
+
+    public BridgedGameProfile getGameProfile() {
+        return BridgedGameProfile.of(internal.getGameProfile());
+    }
+
+    public boolean isServerPlayer() {
+        return internal instanceof ServerPlayer;
+    }
+
+    public Player toMojang() {
+        return internal;
+    }
+
+    public BridgedBlockPos getOnPos() {
+        return BridgedBlockPos.of(internal.getOnPos());
+    }
+
+    @Nullable
+    public ServerGamePacketListenerImpl getConnection() {
+        if (isServerPlayer()) {
+            return ((ServerPlayer) internal).connection;
+        }
+        return null;
+    }
+
+    public ServerPlayer toMojangServerPlayer() {
+        return (ServerPlayer) internal;
+    }
+}