Release 2.0.22 (#234)

* feat: add verification timing and map captcha timing to bstats charts

* fix: use correct char ids for bStats

* fix: implement shutdown method to correctly stop certain services

* style: small codestyle improvements

.github/README.md

@@ -9,6 +9,7 @@
   
   <!-- Badges & icons -->
   [![](https://github.com/jonesdevelopment/sonar/actions/workflows/gradle.yml/badge.svg)](https://github.com/jonesdevelopment/sonar/actions/workflows/gradle.yml)
+  [![](https://www.codefactor.io/repository/github/jonesdevelopment/sonar/badge/main)](https://www.codefactor.io/repository/github/jonesdevelopment/sonar/overview/main)
   [![](https://img.shields.io/github/v/release/jonesdevelopment/sonar)](https://github.com/jonesdevelopment/sonar/releases)
   [![](https://img.shields.io/github/issues/jonesdevelopment/sonar)](https://github.com/jonesdevelopment/sonar/issues)
   [![](https://img.shields.io/discord/923308209769426994.svg?logo=discord)](https://jonesdev.xyz/discord)
@@ -24,7 +25,7 @@
   |
   [Discord](https://jonesdev.xyz/discord)
   |
-  [License](https://github.com/jonesdevelopment/sonar/blob/main/README.md#license)
+  [License](https://github.com/jonesdevelopment/sonar/?tab=readme-ov-file#license)
 </div>
 
 ## Design and Goal
@@ -32,27 +33,21 @@
 * Effective, lightweight, and easy-to-use
 * No unnecessary features and clean code
 * Protection against all kinds of bot attacks
-* No player should be annoyed by any sort of captcha
+* No player should be annoyed by any sort of [CAPTCHA](https://en.wikipedia.org/wiki/CAPTCHA)
 * No sort of checking for VPNs or proxies
-* Multi-platform support (Velocity, BungeeCord, and Bukkit)
+* Multi-platform support (See [supported versions](https://docs.jonesdev.xyz/sonar/supported-versions))
 
 ## Checks
 
-- New player logins are queued to prevent spam login attacks.
-- [Fallback](https://github.com/jonesdevelopment/sonar#fallback) is Sonar's main component designed to prevent
-  all types of bots.
-- Spigot & BungeeCord
-  - The compression method is changed
-    to [Velocity's libdeflate](https://github.com/PaperMC/Velocity/tree/dev/3.0.0/native).
-  - The Varint decoder is updated to Velocity's
-    improved [MinecraftVarintFrameDecoder](https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/netty/MinecraftVarintFrameDecoder.java).
+- [Fallback](https://github.com/jonesdevelopment/sonar#fallback) is Sonar's main anti-bot component
+- Sonar queues new player logins to prevent spam login attacks
+- Sonar checks the handshake packets for legitimacy
+- Sonar makes sure some packets cannot be duplicated illegitimately
 
 ### Fallback
 
-Fallback analyzes a player's behavior before joining the actual server, therefore stopping malicious traffic from ever
-reaching the backend.
-It is supposed to be an instant, powerful, and invisible method of verification that should prevent all typical and
-advanced types of bots.
+Fallback analyzes a player's behavior before joining the actual server, therefore stopping malicious traffic from ever reaching the backend.
+It is supposed to be an instant, powerful, and invisible method of verification that should prevent all typical and advanced types of bots.
 
 * Sends the player to a lightweight fake server when they connect for the first time.
 * Analyzes if the player is sending the necessary packets.
@@ -60,16 +55,11 @@ advanced types of bots.
 * Checks if the player is obeying client gravity.
 * Checks if the player is colliding with blocks correctly.
 
-Fallback also protects from huge spambot attacks since it queues the incoming connections, therefore making it
-technically impossible to have a ton of bots join the server at the same time.
+Fallback also protects against huge spambot attacks since it queues the incoming connections, therefore making it technically impossible to have a ton of bots join the server at the same time.
 
 ### False positives
 
-Fallback is unlikely to ever falsely prevent a player from joining the server since Minecraft uses the TCP protocol which means that packets are always sent in the correct order. Therefore, lag or ping should not affect the bot check.
-However, there are some edge cases where Fallback might not receive packets within the necessary time period. In this case, Sonar tries to account for these edge cases in order to prevent false positives. For example, some higher Minecraft versions have a bug where the client sometimes sends a packet out of order. Sonar accounts for that and does not falsely blacklist clients.
-If you or one of your players experiences a false positive, make sure to report it by opening
-a [GitHub issue](https://github.com/jonesdevelopment/sonar/issues) or a ticket
-on [Discord](https://jonesdev.xyz/discord/).
+Fallback is unlikely to ever falsely prevent a player from joining the server since Minecraft uses the TCP protocol, which means that packets are always sent in the correct order. Therefore, lag or ping should not affect the bot check. However, there are some edge cases where Fallback might not receive packets within the necessary time period. In this case, Sonar tries to account for these edge cases in order to prevent false positives. If you or one of your players experiences a false positive, make sure to report it by opening a [GitHub issue](https://github.com/jonesdevelopment/sonar/issues) or a ticket on [Discord](https://jonesdev.xyz/discord/).
 
 ## Building
 
@@ -79,9 +69,7 @@ You can also take a look at the [gradle documentation](https://docs.gradle.org/c
 
 ## Contributing
 
-If you are interested in contributing, you can check out
-the [Contributing Guidelines](https://github.com/jonesdevelopment/sonar/blob/main/.github/CONTRIBUTING.md) for detailed
-instructions.
+If you are interested in contributing, you can check out the [Contributing Guidelines](https://github.com/jonesdevelopment/sonar/blob/main/.github/CONTRIBUTING.md) for detailed instructions.
 
 ## License
 
@@ -90,5 +78,4 @@ Sonar is licensed under the [GNU General Public License 3.0](https://www.gnu.org
 ## Credits
 
 - Special thanks to the [contributors of Sonar](https://github.com/jonesdevelopment/sonar/graphs/contributors).
-- The nbt mappings were taken from [LimboAPI](https://github.com/Elytrium/LimboAPI).
-- The compression and Varint decoding was taken from [Velocity](https://github.com/PaperMC/Velocity).
+- The Varint decoding was taken from [Velocity](https://github.com/PaperMC/Velocity).

.github/SECURITY.md

@@ -13,13 +13,9 @@ If you discover a security vulnerability within Sonar, please follow these steps
 
 ## Contact
 
-If you have any questions or concerns regarding the security of this project, please open a ticket on Discord or contact me via email at admin@jonesdev.xyz.
+If you have any questions or concerns regarding the security of this project, please open a ticket on Discord or contact me via email at contact@jonesdev.xyz.
 
 ## Acknowledgments
 
-Special thanks to the following people for their contributions:
-- [xism4](https://github.com/xism4)
-  - fixed serious issues with packet decode logic on BungeeCord [#5](https://github.com/jonesdevelopment/sonar-legacy/pull/5) (Severity: medium)
-  - fixed a false blacklisting issue when a player looses connection [#9](https://github.com/jonesdevelopment/sonar-legacy/pull/9) (Severity: low)
-- [NoGodHenry](https://github.com/NoGodHenry)
-  - fixed a ConcurrentModificationException in the configuration [#3](https://github.com/jonesdevelopment/sonar-legacy/pull/3) (Severity: low)
+- Special thanks to the [contributors of Sonar](https://github.com/jonesdevelopment/sonar/graphs/contributors),
+  and also those who reported security issues or bugs.

.github/workflows/gradle.yml

@@ -22,10 +22,10 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
-    - name: Set up JDK 11
+    - name: Set up JDK 17
       uses: actions/setup-java@v3
       with:
-        java-version: '11'
+        java-version: '17'
         distribution: 'temurin'
     - name: Build with Gradle
       uses: gradle/gradle-build-action@bd5760595778326ba7f1441bcf7e88b49de61a25 # v2.6.0

.gitignore

@@ -30,6 +30,5 @@ gradlew*
 *.jpg
 *.jpeg
 *.log
-*.yml
 *.svg
 *.txt

build.gradle.kts

@@ -6,7 +6,7 @@ buildscript {
 
 plugins {
   id("java")
-  id("com.github.johnrengelman.shadow") version "8.1.1"
+  id("io.github.goooler.shadow") version "8.1.5"
   id("io.toolebox.git-versioner") version "1.6.7"
 }
 
@@ -21,15 +21,12 @@ versioner {
 allprojects {
   repositories {
     mavenCentral() // Lombok
-    maven(url = "https://jitpack.io") // simple-yaml
-    maven(url = "https://repo.papermc.io/repository/maven-public") // Velocity natives
     maven(url = "https://repo.jonesdev.xyz/releases/") // Bungee & Velocity proxy module
+    maven(url = "https://s01.oss.sonatype.org/content/repositories/snapshots/") // libby
   }
-}
 
-subprojects {
   apply(plugin = "java")
-  apply(plugin = "com.github.johnrengelman.shadow")
+  apply(plugin = "io.github.goooler.shadow")
 
   dependencies {
     compileOnly("org.projectlombok:lombok:1.18.30")
@@ -38,16 +35,17 @@ subprojects {
     testCompileOnly("org.projectlombok:lombok:1.18.30")
     testAnnotationProcessor("org.projectlombok:lombok:1.18.30")
 
-    // MiniMessage
-    implementation("net.kyori:adventure-text-minimessage:4.14.0")
-    implementation("net.kyori:adventure-text-serializer-gson:4.14.0")
-    implementation("net.kyori:adventure-text-serializer-legacy:4.14.0")
+    // adventure
+    implementation("net.kyori:adventure-text-minimessage:4.16.0")
+    implementation("net.kyori:adventure-text-serializer-gson:4.16.0")
+    implementation("net.kyori:adventure-nbt:4.16.0")
 
-    implementation("net.kyori:adventure-nbt:4.14.0") // nbt
-    implementation("com.j256.ormlite:ormlite-jdbc:6.1") // ORM
-    implementation("xyz.jonesdev:cappuccino:0.1.6-SNAPSHOT") // expiring cache
+    compileOnly("com.j256.ormlite:ormlite-jdbc:6.1") // ORMLite
+    compileOnly("com.github.ben-manes.caffeine:caffeine:3.1.8") // caching
+    compileOnly("io.netty:netty-all:4.1.107.Final") // netty
 
-    compileOnly("io.netty:netty-all:4.1.99.Final") // netty
+    // Library/dependency loading
+    compileOnly("com.alessiodp.libby:libby-core:2.0.0-SNAPSHOT")
   }
 }
 
@@ -69,10 +67,34 @@ tasks {
   }
 
   shadowJar {
-    // bStats has to be relocated to the Sonar package otherwise it throws an exception.
-    relocate("org.bstats", "xyz.jonesdev.sonar.bstats")
     // Set the file name of the shadowed jar
     archiveFileName.set("${rootProject.name}.jar")
+
+    // Remove file timestamps
+    isPreserveFileTimestamps = false
+
+    // Relocate libraries
+    relocate("org.bstats", "xyz.jonesdev.sonar.libs.bstats")
+    relocate("com.alessiodp.libby", "xyz.jonesdev.sonar.libs.libby")
+    relocate("com.simpleyaml", "xyz.jonesdev.sonar.libs.yaml")
+    relocate("com.google.gson", "xyz.jonesdev.sonar.libs.gson")
+    relocate("com.j256.ormlite", "xyz.jonesdev.sonar.libs.ormlite")
+    relocate("com.github.benmanes.caffeine", "xyz.jonesdev.sonar.libs.caffeine")
+    relocate("com.mysql", "xyz.jonesdev.sonar.libs.mysql")
+    relocate("org.mariadb", "xyz.jonesdev.sonar.libs.mariadb")
+
+    // TODO: actually fix this :/
+    // We have to be careful here, so we don't accidentally break adventure
+    relocate("net.kyori", "xyz.jonesdev.sonar.libs.kyori") {
+      exclude("net.kyori.adventure.text.**")
+      exclude("net.kyori.adventure.audience.Audience")
+      exclude("net.kyori.adventure.title.*")
+    }
+
+    // Exclude unnecessary metadata information
+    exclude("META-INF/*/**")
+    // We want to load our own Gson dynamically
+    exclude("com/google/gson/**")
   }
 
   compileJava {

gradle.properties

@@ -1,2 +1,3 @@
 group=xyz.jonesdev.sonar
-version=2.0.2
+version=2.0.22
+description=Effective Anti-bot plugin for Velocity, BungeeCord, and Bukkit (1.7-latest)

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

sonar-api/build.gradle.kts

@@ -1,8 +1,14 @@
+repositories {
+  maven(url = "https://jitpack.io/") // simple-yaml
+}
+
 dependencies {
-  implementation("com.github.Carleslc.Simple-YAML:Simple-Yaml:1.8.4") // yaml config
+  compileOnly("com.github.Carleslc.Simple-YAML:Simple-Yaml:1.8.4") {
+    exclude(group = "org.yaml")
+  }
 
   compileOnly("org.jetbrains:annotations:24.0.1")
 }
 
-java.sourceCompatibility = JavaVersion.VERSION_1_8
-java.targetCompatibility = JavaVersion.VERSION_1_8
+java.sourceCompatibility = JavaVersion.VERSION_11
+java.targetCompatibility = JavaVersion.VERSION_11

sonar-api/src/main/java/xyz/jonesdev/sonar/api/AlreadyInitializedException.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-api/src/main/java/xyz/jonesdev/sonar/api/ReflectiveOperationException.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-api/src/main/java/xyz/jonesdev/sonar/api/Sonar.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,27 +17,38 @@
 
 package xyz.jonesdev.sonar.api;
 
+import net.kyori.adventure.audience.Audience;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.attack.AttackTracker;
 import xyz.jonesdev.sonar.api.command.subcommand.SubcommandRegistry;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
 import xyz.jonesdev.sonar.api.controller.VerifiedPlayerController;
 import xyz.jonesdev.sonar.api.event.SonarEventManager;
 import xyz.jonesdev.sonar.api.fallback.Fallback;
 import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
-import xyz.jonesdev.sonar.api.server.ServerWrapper;
+import xyz.jonesdev.sonar.api.statistics.SonarStatistics;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;
+import xyz.jonesdev.sonar.api.verbose.Notification;
 import xyz.jonesdev.sonar.api.verbose.Verbose;
 
 import java.io.File;
 import java.text.DecimalFormat;
+import java.util.UUID;
 
 public interface Sonar {
   DecimalFormat DECIMAL_FORMAT = new DecimalFormat("#,###.##");
-  String LINE_SEPARATOR = "\n"; // Using System.lineSeparator is broken, for some reason...
 
   /**
-   * @return A small wrapper for the server
+   * Since we want to use Adventure on every server platform,
+   * we have to use their platform module to support BungeeCord and Bukkit
    */
-  @NotNull ServerWrapper getServer();
+  @Nullable Audience audience(final @Nullable UUID uniqueId);
+
+  /**
+   * @return The platform the plugin is being run on
+   */
+  @NotNull SonarPlatform getPlatform();
 
   /**
    * @return A small wrapper for the plugin logger so we can use the logger everywhere
@@ -54,30 +65,49 @@ public interface Sonar {
 
   @NotNull Verbose getVerboseHandler();
 
+  @NotNull Notification getNotificationHandler();
+
+  @NotNull SystemTimer getLaunchTimer();
+
+  @NotNull SonarStatistics getStatistics();
+
   /**
    * Set a custom verbose handler
    */
+  @SuppressWarnings("unused")
   void setVerboseHandler(final @NotNull Verbose verboseHandler);
 
+  /**
+   * Set a custom notification handler
+   */
+  @SuppressWarnings("unused")
+  void setNotificationHandler(final @NotNull Notification notificationHandler);
+
   /**
    * Reloads the entire plugin
    */
   void reload();
 
-  @NotNull
-  default SonarEventManager getEventManager() {
-    return SonarEventManager.INSTANCE;
-  }
-
   @NotNull
   default SonarVersion getVersion() {
     return SonarVersion.GET;
   }
 
+  @NotNull
+  default SonarEventManager getEventManager() {
+    // We don't want anyone else to create a new instance.
+    return SonarEventManager.INSTANCE;
+  }
+
+  @NotNull
+  default AttackTracker getAttackTracker() {
+    // We don't want anyone else to create a new instance.
+    return AttackTracker.INSTANCE;
+  }
+
   @NotNull
   default Fallback getFallback() {
-    // We only have one single instance of Fallback,
-    // and we don't want anyone else to create a new instance.
+    // We don't want anyone else to create a new instance.
     return Fallback.INSTANCE;
   }
 

sonar-api/src/main/java/xyz/jonesdev/sonar/api/SonarPlatform.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-api/src/main/java/xyz/jonesdev/sonar/api/SonarSupplier.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-api/src/main/java/xyz/jonesdev/sonar/api/SonarVersion.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-api/src/main/java/xyz/jonesdev/sonar/api/attack/AttackTracker.java

@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.attack;
+
+import lombok.*;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.config.SonarConfiguration;
+import xyz.jonesdev.sonar.api.event.impl.AttackDetectedEvent;
+import xyz.jonesdev.sonar.api.event.impl.AttackMitigatedEvent;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;
+
+import java.util.Optional;
+
+import static xyz.jonesdev.sonar.api.jvm.JVMProcessInformation.*;
+
+@Getter
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class AttackTracker {
+  public static final AttackTracker INSTANCE = new AttackTracker();
+  private @Nullable AttackStatistics currentAttack;
+  private int attackThreshold;
+
+  @Getter
+  @ToString
+  @RequiredArgsConstructor
+  public static final class AttackStatistics {
+    private final SystemTimer duration = new SystemTimer();
+    private final SystemTimer timer = new SystemTimer();
+    private long peakJoinsPerSecond;
+    private long peakConnectionsPerSecond;
+    private double peakProcessCPUUsage;
+    private long peakProcessMemoryUsage;
+    // Calculate during-attack-statistics using their deltas
+    private int successfulVerifications, failedVerifications;
+  }
+
+  public void checkIfUnderAttack() {
+    final long joinsPerSecond = Sonar.get().getStatistics().getLoginsPerSecond();
+    final int verifyingPlayers = Sonar.get().getFallback().getConnected().size();
+    final int queuedPlayers = Sonar.get().getFallback().getQueue().getQueuedPlayers().size();
+    final int minPlayers = Sonar.get().getConfig().getMinPlayersForAttack();
+
+    if (joinsPerSecond > minPlayers // Check the number of bots/joins per second.
+      || verifyingPlayers > minPlayers // Check the number of verifying players.
+      || queuedPlayers > minPlayers) { // Check the number of queued players.
+      // Increment attack threshold
+      ++attackThreshold;
+
+      // An attack has been detected
+      if (currentAttack == null) {
+        currentAttack = new AttackStatistics();
+        currentAttack.successfulVerifications = Sonar.get().getVerifiedPlayerController().estimatedSize();
+        currentAttack.failedVerifications = Sonar.get().getStatistics().getTotalFailedVerifications();
+        Sonar.get().getEventManager().publish(new AttackDetectedEvent());
+        Sonar.get().getNotificationHandler().sendAttackNotification();
+      } else {
+        // Reset attack timer if we're still under attack
+        currentAttack.timer.reset();
+      }
+
+      // Update attack statistics
+      if (joinsPerSecond > currentAttack.peakJoinsPerSecond) {
+        // Update joins per second peak if necessary
+        currentAttack.peakJoinsPerSecond = joinsPerSecond;
+      }
+      final long connectionsPerSecond = Sonar.get().getStatistics().getConnectionsPerSecond();
+      if (connectionsPerSecond > currentAttack.peakConnectionsPerSecond) {
+        // Update connections per second peak if necessary
+        currentAttack.peakConnectionsPerSecond = connectionsPerSecond;
+      }
+      final double processCPUUsage = getProcessCPUUsage();
+      if (processCPUUsage > currentAttack.peakProcessCPUUsage) {
+        // Update cpu usage peak if necessary
+        currentAttack.peakProcessCPUUsage = processCPUUsage;
+      }
+      final long processMemoryUsage = getUsedMemory();
+      if (processMemoryUsage > currentAttack.peakProcessMemoryUsage) {
+        // Update memory consumption peak if necessary
+        currentAttack.peakProcessMemoryUsage = processMemoryUsage;
+      }
+    } else if (currentAttack != null) {
+      if (currentAttack.duration.delay() > Sonar.get().getConfig().getMinAttackDuration()
+        && currentAttack.timer.delay() > Sonar.get().getConfig().getAttackCooldownDelay()) {
+        // The current attack has stopped
+        Sonar.get().getEventManager().publish(new AttackMitigatedEvent(currentAttack));
+
+        if (++attackThreshold > Sonar.get().getConfig().getMinAttackThreshold()) {
+          // Post webhook to Discord
+          Optional.ofNullable(Sonar.get().getConfig().getWebhook().getDiscordWebhook())
+            .ifPresent(webhook -> {
+              // Save attack statistics
+              final long deltaInMillis = currentAttack.duration.delay();
+              final String peakCPU = Sonar.DECIMAL_FORMAT.format(currentAttack.peakProcessCPUUsage);
+              final String peakMem = formatMemory(currentAttack.peakProcessMemoryUsage);
+              final String peakBPS = Sonar.DECIMAL_FORMAT.format(currentAttack.peakJoinsPerSecond);
+              final String peakCPS = Sonar.DECIMAL_FORMAT.format(currentAttack.peakConnectionsPerSecond);
+              final long minutes = deltaInMillis / (60 * 1000); // Convert milliseconds to minutes
+              final double seconds = (deltaInMillis % (60 * 1000)) / 1000D; // Convert remaining milliseconds to seconds
+              final String formattedDuration = String.format("%d minutes, %.0f seconds", minutes, seconds);
+              final String startTimestamp = String.valueOf(currentAttack.duration.getStart() / 1000L);
+              final String endTimestamp = String.valueOf(System.currentTimeMillis() / 1000L);
+              final long blacklisted = Sonar.get().getFallback().getBlacklist().estimatedSize();
+              // Calculate during-attack-statistics using their deltas
+              final long totalVerified = Sonar.get().getVerifiedPlayerController().estimatedSize();
+              final long verified = Math.max(totalVerified - currentAttack.successfulVerifications, 0);
+              final long totalFailed = Sonar.get().getStatistics().getTotalFailedVerifications();
+              final long failed = Math.max(totalFailed - currentAttack.failedVerifications, 0);
+
+              webhook.post(() -> {
+                final SonarConfiguration.Webhook.Embed config = Sonar.get().getConfig().getWebhook().getEmbed();
+                final String description = config.getDescription()
+                  .replace("%start-timestamp%", startTimestamp)
+                  .replace("%end-timestamp%", endTimestamp)
+                  .replace("%duration%", formattedDuration)
+                  .replace("%peak-cpu%", peakCPU)
+                  .replace("%peak-memory%", peakMem)
+                  .replace("%peak-bps%", peakBPS)
+                  .replace("%peak-cps%", peakCPS)
+                  .replace("%total-blacklisted%", Sonar.DECIMAL_FORMAT.format(blacklisted))
+                  .replace("%total-failed%", Sonar.DECIMAL_FORMAT.format(failed))
+                  .replace("%total-success%", Sonar.DECIMAL_FORMAT.format(verified));
+                return new SonarConfiguration.Webhook.Embed(
+                  config.getTitle(), config.getTitleUrl(), description, config.getR(), config.getG(), config.getB());
+              });
+            });
+        }
+
+        // Reset the attack status
+        currentAttack = null;
+        // Reset threshold
+        attackThreshold = 0;
+      }
+    } else {
+      // Reset threshold
+      attackThreshold = 0;
+    }
+  }
+
+  @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+  public boolean isCurrentlyUnderAttack() {
+    final int minDelay = Sonar.get().getConfig().getAttackCooldownDelay();
+    return currentAttack != null && currentAttack.timer.delay() < minDelay;
+  }
+}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/command/CommandInvocation.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,12 +19,14 @@ package xyz.jonesdev.sonar.api.command;
 
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
+import lombok.ToString;
 import xyz.jonesdev.sonar.api.command.subcommand.Subcommand;
 
 @Getter
 @RequiredArgsConstructor
+@ToString(of = "rawArguments")
 public final class CommandInvocation {
   private final InvocationSource sender;
-  private final Subcommand command;
+  private final Subcommand subcommand;
   private final String[] rawArguments;
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/command/InvocationSource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,13 +21,18 @@ import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+
+import java.util.UUID;
+import java.util.function.Predicate;
 
 @Getter
 @RequiredArgsConstructor
 public abstract class InvocationSource {
-  private final String name;
+  private final UUID uuid;
   private final Audience audience;
+  private final boolean player;
+  private final Predicate<String> permissionFunction;
 
   /**
    * Sends an empty chat message to the command executor
@@ -40,7 +45,7 @@ public abstract class InvocationSource {
    * Sends a message to the command executor
    */
   public final void sendMessage(final String legacy) {
-    sendMessage(LegacyComponentSerializer.legacyAmpersand().deserialize(legacy));
+    sendMessage(MiniMessage.miniMessage().deserialize(legacy));
   }
 
   /**

sonar-api/src/main/java/xyz/jonesdev/sonar/api/command/SonarCommand.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,69 +17,139 @@
 
 package xyz.jonesdev.sonar.api.command;
 
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.event.ClickEvent;
-import net.kyori.adventure.text.event.HoverEvent;
-import net.kyori.adventure.text.format.NamedTextColor;
-import xyz.jonesdev.cappuccino.Cappuccino;
-import xyz.jonesdev.cappuccino.ExpiringCache;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.command.subcommand.Subcommand;
+import xyz.jonesdev.sonar.api.command.subcommand.argument.Argument;
 
+import java.time.Duration;
 import java.util.*;
+import java.util.stream.Collectors;
+
+import static java.util.Collections.emptyList;
 
 public interface SonarCommand {
   List<String> TAB_SUGGESTIONS = new ArrayList<>();
 
   Map<String, List<String>> ARG_TAB_SUGGESTIONS = new HashMap<>();
 
-  ExpiringCache<Object> DELAY = Cappuccino.buildExpiring(500L);
+  Cache<Audience, Long> COMMAND_DELAY = Caffeine.newBuilder()
+    .expireAfterWrite(Duration.ofMillis(500))
+    .build();
 
-  int COPYRIGHT_YEAR = Calendar.getInstance().get(Calendar.YEAR);
+  List<Component> CACHED_HELP_MESSAGE = new ArrayList<>();
 
-  List<Component> CACHED_HELP_MESSAGE = new Vector<>();
+  default void handle(final @NotNull InvocationSource source, final String[] args) {
+    if (source.isPlayer()) {
+      // Check if the player actually has the permission to run the command
+      if (!source.getPermissionFunction().test("sonar.command")) {
+        source.sendMessage(Sonar.get().getConfig().getNoPermission());
+        return;
+      }
 
-  default void cacheHelpMessage() {
-    CACHED_HELP_MESSAGE.addAll(Arrays.asList(
-      Component.text("Running Sonar " + Sonar.get().getVersion()
-        + " on " + Sonar.get().getServer().getPlatform().getDisplayName()
-        + ".", NamedTextColor.YELLOW),
-      Component.text("(C) " + COPYRIGHT_YEAR + " Jones Development and Sonar Contributors", NamedTextColor.YELLOW),
-      Component.text("https://github.com/jonesdevelopment/sonar", NamedTextColor.GREEN)
-        .clickEvent(net.kyori.adventure.text.event.ClickEvent.clickEvent(net.kyori.adventure.text.event.ClickEvent.Action.OPEN_URL, "https://github.com/jonesdevelopment/sonar")),
-      Component.empty(),
-      Component.text("Need help or have any questions?", NamedTextColor.YELLOW),
-      Component.textOfChildren(
-        Component.text("Open a ticket on the Discord ", NamedTextColor.YELLOW)
-          .hoverEvent(net.kyori.adventure.text.event.HoverEvent.hoverEvent(net.kyori.adventure.text.event.HoverEvent.Action.SHOW_TEXT, Component.text("(Click to open Discord)")))
-          .clickEvent(net.kyori.adventure.text.event.ClickEvent.clickEvent(net.kyori.adventure.text.event.ClickEvent.Action.OPEN_URL, "https://jonesdev.xyz/discord/")),
-        Component.text("or open a new issue on GitHub.", NamedTextColor.YELLOW)
-          .hoverEvent(net.kyori.adventure.text.event.HoverEvent.hoverEvent(net.kyori.adventure.text.event.HoverEvent.Action.SHOW_TEXT, Component.text("(Click to open GitHub)")))
-          .clickEvent(net.kyori.adventure.text.event.ClickEvent.clickEvent(net.kyori.adventure.text.event.ClickEvent.Action.OPEN_URL, "https://github.com/jonesdevelopment/sonar" +
-            "/issues"))
-      ),
-      Component.empty()
-    ));
+      COMMAND_DELAY.cleanUp(); // Clean up the cache
 
-    Sonar.get().getSubcommandRegistry().getSubcommands().forEach(sub -> {
-      Component component = Component.textOfChildren(
-        Component.text(" ▪ ", NamedTextColor.GRAY),
-        Component.text("/sonar " + sub.getInfo().name(), NamedTextColor.GREEN),
-        Component.text(" - ", NamedTextColor.GRAY),
-        Component.text(sub.getInfo().description(), NamedTextColor.WHITE)
-      );
+      final long timestamp = System.currentTimeMillis();
+      final long mapTimestamp = COMMAND_DELAY.asMap().getOrDefault(source.getAudience(), -1L);
 
-      component = component.clickEvent(
-        net.kyori.adventure.text.event.ClickEvent.clickEvent(ClickEvent.Action.SUGGEST_COMMAND,
-          "/sonar " + sub.getInfo().name() + " ")
-      ).hoverEvent(
-        net.kyori.adventure.text.event.HoverEvent.hoverEvent(HoverEvent.Action.SHOW_TEXT, Component.text(
-          "§7Only players: §f" + (sub.getInfo().onlyPlayers() ? "§a✔" : "§c✗")
-            + Sonar.LINE_SEPARATOR + "§7Require console: §f" + (sub.getInfo().onlyConsole() ? "§a✔" : "§c✗")
-            + Sonar.LINE_SEPARATOR + "§7Permission: §f" + sub.getPermission()
-            + Sonar.LINE_SEPARATOR + "§7Aliases: §f" + sub.getAliases()
-        ))
-      );
-      CACHED_HELP_MESSAGE.add(component);
+      // There were some exploits with spamming commands in the past.
+      // Spamming should be prevented, especially if some heavy operations are done,
+      // which is not the case here but let's still stay safe!
+      if (mapTimestamp > 0L) {
+        source.sendMessage(Sonar.get().getConfig().getCommands().getCommandCoolDown());
+
+        // Format delay
+        final double left = 0.5D - (timestamp - mapTimestamp) / 1000D;
+
+        source.sendMessage(Sonar.get().getConfig().getCommands().getCommandCoolDownLeft()
+          .replace("%time-left%", Sonar.DECIMAL_FORMAT.format(left)));
+        return;
+      }
+
+      COMMAND_DELAY.put(source.getAudience(), timestamp);
+    }
+
+    if (args.length > 0) {
+      // Search subcommand if command arguments are present
+      final Optional<Subcommand> subcommand = Sonar.get().getSubcommandRegistry().getSubcommands().stream()
+        .filter(sub -> sub.getInfo().name().equalsIgnoreCase(args[0])
+          || Arrays.stream(sub.getInfo().aliases())
+          .anyMatch(alias -> alias.equalsIgnoreCase(args[0])))
+        .findFirst();
+
+      // Check permissions for subcommands
+      if (subcommand.isPresent()) {
+        if (!subcommand.get().getInfo().onlyConsole()
+          && !source.getPermissionFunction().test(subcommand.get().getPermission())) {
+          source.sendMessage(Sonar.get().getConfig().getCommands().getSubCommandNoPerm()
+            .replace("%permission%", subcommand.get().getPermission()));
+          return;
+        }
+        subcommand.get().invoke(source, args);
+        return;
+      }
+    }
+
+    // Re-use the old, cached help message since we don't want to scan
+    // for each subcommand and it's arguments/attributes every time
+    // someone runs /sonar since the subcommand don't change
+    for (final Component component : CACHED_HELP_MESSAGE) {
+      source.sendMessage(component);
+    }
+  }
+
+  static void prepareCachedMessages() {
+    // Cache help message
+    CACHED_HELP_MESSAGE.clear();
+    for (final String message : Sonar.get().getConfig().getCommands().getHelpHeader()) {
+      CACHED_HELP_MESSAGE.add(MiniMessage.miniMessage().deserialize(message
+        .replace("%version%", Sonar.get().getVersion().getFormatted())
+        .replace("%platform%", Sonar.get().getPlatform().getDisplayName())
+        .replace("%copyright_year%", String.valueOf(Calendar.getInstance().get(Calendar.YEAR)))));
+    }
+
+    final String subcommandFormat = Sonar.get().getConfig().getCommands().getHelpSubcommands();
+    Sonar.get().getSubcommandRegistry().getSubcommands().forEach(subcommand -> {
+      final Component deserialized = MiniMessage.miniMessage().deserialize(subcommandFormat
+        .replace("%subcommand%", subcommand.getInfo().name())
+        .replace("%description%", subcommand.getInfo().description())
+        .replace("%only_players%", subcommand.getInfo().onlyPlayers() ? "<green>✔</green>" : "<red>✗</red>")
+        .replace("%require_console%", subcommand.getInfo().onlyConsole() ? "<green>✔</green>" : "<red>✗</red>")
+        .replace("%permission%", subcommand.getPermission())
+        .replace("%aliases%", subcommand.getAliases()));
+      CACHED_HELP_MESSAGE.add(deserialized);
     });
+
+    // Don't re-cache tab suggestions
+    if (!TAB_SUGGESTIONS.isEmpty()) return;
+    // Cache tab suggestions
+    for (final Subcommand subcommand : Sonar.get().getSubcommandRegistry().getSubcommands()) {
+      TAB_SUGGESTIONS.add(subcommand.getInfo().name());
+      if (subcommand.getInfo().aliases().length > 0) {
+        TAB_SUGGESTIONS.addAll(Arrays.asList(subcommand.getInfo().aliases()));
+      }
+      final List<String> parsedArguments = Arrays.stream(subcommand.getInfo().arguments())
+        .map(Argument::value)
+        .collect(Collectors.toList());
+      ARG_TAB_SUGGESTIONS.put(subcommand.getInfo().name(), parsedArguments);
+      for (final String alias : subcommand.getInfo().aliases()) {
+        ARG_TAB_SUGGESTIONS.put(alias, parsedArguments);
+      }
+    }
+  }
+
+  default List<String> getCachedTabSuggestions(final String @NotNull [] arguments) {
+    if (arguments.length <= 1) {
+      return TAB_SUGGESTIONS;
+    } else if (arguments.length == 2) {
+      final String subCommandName = arguments[0].toLowerCase();
+      return ARG_TAB_SUGGESTIONS.getOrDefault(subCommandName, emptyList());
+    }
+    return emptyList();
   }
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/command/subcommand/Subcommand.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,23 +19,23 @@ package xyz.jonesdev.sonar.api.command.subcommand;
 
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.command.CommandInvocation;
 import xyz.jonesdev.sonar.api.command.InvocationSource;
 import xyz.jonesdev.sonar.api.command.subcommand.argument.Argument;
 
+import java.net.InetAddress;
+import java.net.UnknownHostException;
 import java.util.Arrays;
-import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 @Getter
 public abstract class Subcommand {
   private final @NotNull SubcommandInfo info;
   private final String permission, aliases, arguments;
+
   protected static final Sonar SONAR = Sonar.get();
-  protected static final Pattern IP_PATTERN = Pattern.compile(
-    "^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])([.])){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$"
-  );
 
   public Subcommand() {
     info = getClass().getAnnotation(SubcommandInfo.class);
@@ -49,10 +49,52 @@ public abstract class Subcommand {
       .collect(Collectors.joining(", "));
   }
 
+  protected static @Nullable InetAddress getInetAddressIfValid(final InvocationSource source, final String rawIP) {
+    final InetAddress inetAddress;
+    try {
+      inetAddress = InetAddress.getByName(rawIP);
+
+      if (inetAddress.isAnyLocalAddress() || inetAddress.isLoopbackAddress()) {
+        source.sendMessage(SONAR.getConfig().getCommands().getIllegalIpAddress());
+        return null;
+      }
+    } catch (UnknownHostException exception) {
+      source.sendMessage(SONAR.getConfig().getCommands().getIncorrectIpAddress());
+      return null;
+    }
+    return inetAddress;
+  }
+
   protected final void incorrectUsage(final @NotNull InvocationSource sender) {
-    sender.sendMessage(SONAR.getConfig().getIncorrectCommandUsage()
+    sender.sendMessage(SONAR.getConfig().getCommands().getIncorrectCommandUsage()
       .replace("%usage%", info.name() + " (" + arguments + ")"));
   }
 
-  public abstract void execute(final @NotNull CommandInvocation invocation);
+  public final void invoke(final @NotNull InvocationSource invocationSource, final String @NotNull [] arguments) {
+    // Check if the subcommand can only be executed by players
+    if (getInfo().onlyPlayers() && !invocationSource.isPlayer()) {
+      invocationSource.sendMessage(Sonar.get().getConfig().getCommands().getPlayersOnly());
+      return;
+    }
+
+    // Check if the subcommand can only be executed though console
+    if (getInfo().onlyConsole() && invocationSource.isPlayer()) {
+      invocationSource.sendMessage(Sonar.get().getConfig().getCommands().getConsoleOnly());
+      return;
+    }
+
+    final CommandInvocation commandInvocation = new CommandInvocation(invocationSource, this, arguments);
+
+    // The subcommands has arguments which are not present in the executed command
+    if (getInfo().argumentsRequired() && getInfo().arguments().length > 0 && arguments.length <= 1) {
+      invocationSource.sendMessage(Sonar.get().getConfig().getCommands().getIncorrectCommandUsage()
+        .replace("%usage%", getInfo().name() + " (" + getArguments() + ")"));
+      return;
+    }
+
+    // Execute the sub command
+    execute(commandInvocation);
+  }
+
+  protected abstract void execute(final @NotNull CommandInvocation invocation);
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/command/subcommand/SubcommandInfo.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-api/src/main/java/xyz/jonesdev/sonar/api/command/subcommand/SubcommandRegistry.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-api/src/main/java/xyz/jonesdev/sonar/api/command/subcommand/argument/Argument.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-api/src/main/java/xyz/jonesdev/sonar/api/config/Language.java

@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.config;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+@Getter
+enum Language {
+  SYSTEM("system"),
+  AB("Abkhazian"),
+  AA("Afar"),
+  AF("Afrikaans"),
+  SQ("Albanian"),
+  AM("Amharic"),
+  AR("Arabic"),
+  AN("Aragonese"),
+  HY("Armenian"),
+  AS("Assamese"),
+  AE("Avestan"),
+  AY("Aymara"),
+  AZ("Azerbaijani"),
+  BA("Bashkir"),
+  EU("Basque"),
+  BE("Belarusian"),
+  BN("Bengali"),
+  BH("Bihari"),
+  BI("Bislama"),
+  BS("Bosnian"),
+  BR("Breton"),
+  BG("Bulgarian"),
+  MY("Burmese"),
+  CA("Catalan"),
+  CH("Chamorro"),
+  CE("Chechen"),
+  ZH("Chinese"),
+  CU("Slavic"),
+  CV("Chuvash"),
+  KW("Cornish"),
+  CO("Corsican"),
+  HR("Croatian"),
+  CS("Czech"),
+  DA("Danish"),
+  DV("Maldivian"),
+  NL("Dutch"),
+  DZ("Dzongkha"),
+  EN("English"),
+  EO("Esperanto"),
+  ET("Estonian"),
+  FO("Faroese"),
+  FJ("Fijian"),
+  FI("Finnish"),
+  FR("French"),
+  GD("Gaelic"),
+  GL("Galician"),
+  KA("Georgian"),
+  DE("German"),
+  EL("Greek"),
+  GN("Guarani"),
+  GU("Gujarati"),
+  HT("Haitian Creole"),
+  HA("Hausa"),
+  HE("Hebrew"),
+  HZ("Herero"),
+  HI("Hindi"),
+  HO("Hiri Motu"),
+  HU("Hungarian"),
+  IS("Icelandic"),
+  IO("Ido"),
+  ID("Indonesian"),
+  IE("Interlingue"),
+  IU("Inuktitut"),
+  IK("Inupiaq"),
+  GA("Irish"),
+  IT("Italian"),
+  JA("Japanese"),
+  JV("Javanese"),
+  KL("Kalaallisut"),
+  KN("Kannada"),
+  KS("Kashmiri"),
+  KK("Kazakh"),
+  KM("Khmer"),
+  KI("Kikuyu"),
+  RW("Kinyarwanda"),
+  KY("Kirghiz"),
+  KV("Komi"),
+  KO("Korean"),
+  KJ("Kwanyama"),
+  KU("Kurdish"),
+  LO("Lao"),
+  LA("Latin"),
+  LV("Latvian"),
+  LI("Limburgish"),
+  LN("Lingala"),
+  LT("Lithuanian"),
+  LB("Luxembourgish"),
+  MK("Macedonian"),
+  MG("Malagasy"),
+  MS("Malay"),
+  ML("Malayalam"),
+  MT("Maltese"),
+  GV("Manx"),
+  MI("Maori"),
+  MR("Marathi"),
+  MH("Marshallese"),
+  MO("Moldavian"),
+  MN("Mongolian"),
+  NA("Nauru"),
+  NV("Navajo"),
+  ND("Ndebele, North"),
+  NR("Ndebele, South"),
+  NG("Ndonga"),
+  NE("Nepali"),
+  SE("Northern Sami"),
+  NO("Norwegian"),
+  NB("Norwegian Bokmal"),
+  NN("Norwegian Nynorsk"),
+  NY("Chewa"),
+  OC("Occitan"),
+  OR("Oriya"),
+  OM("Oromo"),
+  OS("Ossetian"),
+  PI("Pali"),
+  PA("Panjabi"),
+  FA("Persian"),
+  PL("Polish"),
+  PT("Portuguese"),
+  PS("Pushto"),
+  QU("Quechua"),
+  RM("Raeto-Romance"),
+  RO("Romanian"),
+  RN("Rundi"),
+  RU("Russian"),
+  SM("Samoan"),
+  SG("Sango"),
+  SA("Sanskrit"),
+  SC("Sardinian"),
+  SR("Serbian"),
+  SN("Shona"),
+  II("Sichuan Yi"),
+  SD("Sindhi"),
+  SI("Sinhala"),
+  SK("Slovak"),
+  SL("Slovenian"),
+  SO("Somali"),
+  ST("Sotho, Southern"),
+  ES("Spanish"),
+  SU("Sundanese"),
+  SW("Swahili"),
+  SS("Swati"),
+  SV("Swedish"),
+  TL("Tagalog"),
+  TY("Tahitian"),
+  TG("Tajik"),
+  TA("Tamil"),
+  TT("Tatar"),
+  TE("Telugu"),
+  TH("Thai"),
+  BO("Tibetan"),
+  TI("Tigrinya"),
+  TO("Tonga"),
+  TS("Tsonga"),
+  TN("Tswana"),
+  TR("Turkish"),
+  TK("Turkmen"),
+  TW("Twi"),
+  UG("Uighur"),
+  UK("Ukrainian"),
+  UR("Urdu"),
+  UZ("Uzbek"),
+  VI("Vietnamese"),
+  VO("Volapuk"),
+  WA("Walloon"),
+  CY("Welsh"),
+  FY("Western Frisian"),
+  WO("Wolof"),
+  XH("Xhosa"),
+  YI("Yiddish"),
+  YO("Yoruba"),
+  ZA("Zhuang"),
+  ZU("Zulu");
+
+  private final String name;
+  private final String code;
+
+  Language(final String name) {
+    this.name = name;
+    this.code = name().toLowerCase();
+  }
+
+  public static Language fromCode(final @NotNull String code) {
+    return Language.valueOf(code.toUpperCase());
+  }
+}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/config/SimpleYamlConfig.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,65 +18,70 @@
 package xyz.jonesdev.sonar.api.config;
 
 import lombok.Getter;
-import org.simpleyaml.configuration.comments.format.YamlCommentFormat;
+import org.jetbrains.annotations.NotNull;
+import org.simpleyaml.configuration.MemorySection;
 import org.simpleyaml.configuration.file.YamlFile;
-import xyz.jonesdev.sonar.api.Sonar;
 
 import java.io.File;
-import java.io.IOException;
-import java.util.Arrays;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
-import static xyz.jonesdev.sonar.api.Sonar.LINE_SEPARATOR;
+import static xyz.jonesdev.sonar.api.config.SonarConfiguration.LOGGER;
 
 @Getter
 public final class SimpleYamlConfig {
   private final File file;
   private final YamlFile yaml;
 
-  private static final List<String> HEADER = Arrays.asList(
-    "",
-    "Sonar anti-bot version " + Sonar.get().getVersion(),
-    " Currently running on: " + Sonar.get().getServer().getPlatform().getDisplayName(),
-    " Need help? https://jonesdev.xyz/discord",
-    ""
-  );
-
-  public SimpleYamlConfig(final File dataFolder, final String fileName) {
-    this(new File(dataFolder, fileName + ".yml"), dataFolder);
-  }
-
-  private SimpleYamlConfig(final File file, final File folder) {
-    if (!folder.exists() && !folder.mkdir()) {
-      throw new IllegalStateException("Could not create folder?!");
-    }
-
+  public SimpleYamlConfig(final @NotNull File file) {
     this.file = file;
     this.yaml = new YamlFile(file.getPath());
   }
 
-  public void save() {
-    try {
-      yaml.save();
-    } catch (IOException exception) {
-      exception.printStackTrace(System.err);
+  private void replaceConfigFile(final @NotNull URL defaultData) throws Exception {
+    try (final InputStream inputStream = defaultData.openStream()) {
+      Files.copy(inputStream, file.toPath(), StandardCopyOption.REPLACE_EXISTING);
     }
   }
 
-  public void load() throws Exception {
-    // https://github.com/jonesdevelopment/sonar/issues/26
-    // Only load the configuration if the file already exists
-    if (yaml.exists()) {
-      yaml.loadWithComments();
-    } else {
-      yaml.createOrLoadWithComments();
+  public void load(final @NotNull URL defaultData) throws Exception {
+    final boolean exists = yaml.exists();
+
+    // Copy the configuration from the translations
+    if (!exists) {
+      replaceConfigFile(defaultData);
     }
 
-    // Always load the comment format and options
-    yaml.setCommentFormat(YamlCommentFormat.PRETTY);
+    // Load the configuration
+    yaml.loadWithComments();
 
-    yaml.options().headerFormatter().commentPrefix("# ");
-    yaml.setHeader(String.join(LINE_SEPARATOR, HEADER));
+    // I hate my life... but this works... somehow
+    if (exists) {
+      // First, we store all values from the current (old) config
+      final Map<String, Object> values = yaml.getValues(true);
+      // Then, we replace the old config file with the default one
+      replaceConfigFile(defaultData);
+      // Re-load the configuration
+      yaml.loadWithComments();
+      // Loop through the new values from the new configuration
+      yaml.getValues(true).forEach((path, v) -> {
+        final Object value = values.get(path);
+        // Make sure we actually need to update the value
+        if (value != null && !value.equals(v)
+          && !(v instanceof MemorySection)
+          && !(value instanceof MemorySection)) {
+          // Set the old values to the new values
+          yaml.set(path, value);
+        }
+      });
+      // Save the yaml file to ensure we keep the original values
+      yaml.save();
+    }
   }
 
   public void set(final String path, final Object v) {
@@ -88,18 +93,81 @@ public final class SimpleYamlConfig {
     return yaml.getInt(path, def);
   }
 
+  public int getInt(final String path) {
+    if (!yaml.contains(path)) {
+      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      return 0;
+    }
+    return yaml.getInt(path);
+  }
+
   public boolean getBoolean(final String path, final boolean def) {
     yaml.addDefault(path, def);
     return yaml.getBoolean(path, def);
   }
 
+  public boolean getBoolean(final String path) {
+    if (!yaml.contains(path)) {
+      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      return false;
+    }
+    return yaml.getBoolean(path);
+  }
+
   public String getString(final String path, final String def) {
+    final Object object = getObject(path, def);
+    if (object instanceof String) {
+      return (String) object;
+    }
+    LOGGER.info("[config] Migrated {} to {}", path, def);
+    set(path, def);
+    return def;
+  }
+
+  public @NotNull String getString(final String path) {
+    if (!yaml.contains(path)) {
+      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      return "";
+    }
+    final Object object = getObject(path);
+    if (object instanceof String) {
+      return (String) object;
+    }
+    throw new IllegalStateException("Invalid entry " + path);
+  }
+
+  public Object getObject(final String path, final Object def) {
     yaml.addDefault(path, def);
-    return yaml.getString(path, def);
+    return yaml.get(path, def);
+  }
+
+  public Object getObject(final String path) {
+    return yaml.get(path);
   }
 
   public List<String> getStringList(final String path, final List<String> def) {
     yaml.addDefault(path, def);
     return yaml.getStringList(path);
   }
+
+  public List<String> getStringList(final String path) {
+    if (!yaml.contains(path)) {
+      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      return new ArrayList<>(0);
+    }
+    return yaml.getStringList(path);
+  }
+
+  public List<Integer> getIntList(final String path, final List<Integer> def) {
+    yaml.addDefault(path, def);
+    return yaml.getIntegerList(path);
+  }
+
+  public List<Integer> getIntList(final String path) {
+    if (!yaml.contains(path)) {
+      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      return new ArrayList<>(0);
+    }
+    return yaml.getIntegerList(path);
+  }
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/controller/VerifiedPlayerController.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,19 +19,24 @@ package xyz.jonesdev.sonar.api.controller;
 
 import com.j256.ormlite.dao.Dao;
 import com.j256.ormlite.dao.DaoManager;
+import com.j256.ormlite.jdbc.JdbcPooledConnectionSource;
 import com.j256.ormlite.stmt.QueryBuilder;
 import com.j256.ormlite.support.ConnectionSource;
 import com.j256.ormlite.table.TableUtils;
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Range;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
-import xyz.jonesdev.sonar.api.dependencies.DependencyLoader;
+import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
 import xyz.jonesdev.sonar.api.model.VerifiedPlayer;
 
 import java.net.InetAddress;
 import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
@@ -41,39 +46,112 @@ public final class VerifiedPlayerController {
   private static final Map<String, Collection<UUID>> MAP = new ConcurrentHashMap<>();
   private static final ExecutorService DB_UPDATE_SERVICE = Executors.newSingleThreadExecutor();
 
+  private static final LoggerWrapper LOGGER = new LoggerWrapper() {
+
+    @Override
+    public void info(final String message, final Object... args) {
+      Sonar.get().getLogger().info("[database] " + message, args);
+    }
+
+    @Override
+    public void warn(final String message, final Object... args) {
+      Sonar.get().getLogger().warn("[database] " + message, args);
+    }
+
+    @Override
+    public void error(final String message, final Object... args) {
+      Sonar.get().getLogger().error("[database] " + message, args);
+    }
+  };
+
   private @Nullable ConnectionSource connectionSource;
   private Dao<VerifiedPlayer, Integer> dao;
   private QueryBuilder<VerifiedPlayer, Integer> queryBuilder;
   @Getter
-  private final @NotNull SonarConfiguration.DatabaseType cachedDatabaseType;
+  private final @NotNull SonarConfiguration.Database.Type cachedDatabaseType;
 
   public VerifiedPlayerController() {
+    final SonarConfiguration.Database database = Sonar.get().getConfig().getDatabase();
     // Cache selected database type, so we don't need to call Sonar.get() every time
-    cachedDatabaseType = Sonar.get().getConfig().getDatabaseType();
+    cachedDatabaseType = database.getType();
 
     // Don't establish a database connection if the type is NONE
-    if (cachedDatabaseType == SonarConfiguration.DatabaseType.NONE) {
-      Sonar.get().getLogger().warn("Make sure to configure a database to save verified players.");
+    if (cachedDatabaseType == SonarConfiguration.Database.Type.NONE) {
+      LOGGER.warn("Configure a database to save verified players.");
       return;
     }
 
-    try (final ConnectionSource connectionSource = DependencyLoader.setUpDriverAndConnect()) {
-      this.connectionSource = connectionSource;
+    // Initialize MySQL/MariaDB driver
+    database.getType().getDatabaseType().loadDriver();
+
+    try {
+      connectionSource = new JdbcPooledConnectionSource(
+        String.format(database.getType().getConnectionString(),
+          database.getHost(), database.getPort(), database.getName()),
+        database.getUsername(), database.getPassword(), database.getType().getDatabaseType());
 
       // Create table
       try {
         TableUtils.createTableIfNotExists(connectionSource, VerifiedPlayer.class);
       } catch (SQLException exception) {
         // Duplicate index
+        // I know this isn't the best method of handling it,
+        // but I don't know how else I could address this issue.
       }
 
       dao = DaoManager.createDao(connectionSource, VerifiedPlayer.class);
       queryBuilder = dao.queryBuilder();
 
-      dao.queryForAll().forEach(this::_add);
-    } catch (Throwable throwable) {
-      Sonar.get().getLogger().error("Error setting up database connection: {}", throwable);
-      throwable.printStackTrace(System.err);
+      // Make sure to run the clean task and the caching task in the same thread
+      // https://github.com/jonesdevelopment/sonar/issues/150
+      DB_UPDATE_SERVICE.execute(() -> {
+        try {
+          // Make sure to clear all outdated entries first
+          clearOld(database.getMaximumAge());
+          // Add all entries from the database to the cache
+          dao.queryForAll().forEach(this::_add);
+        } catch (SQLException exception) {
+          LOGGER.error("Error initializing database: {}", exception);
+        }
+      });
+    } catch (SQLException exception) {
+      LOGGER.error("Error setting up database: {}", exception);
+    }
+  }
+
+  /**
+   * Closes the connection if instantiated
+   */
+  public void close() {
+    // The connection source will always be null if the database type is NONE.
+    if (connectionSource != null) {
+      try {
+        // Properly close the connection
+        connectionSource.close();
+      } catch (Exception exception) {
+        LOGGER.error("Error closing database: {}", exception);
+      }
+    }
+  }
+
+  /**
+   * Clear all old entries using the given timestamp.
+   */
+  private void clearOld(final @Range(from = 1, to = 365) int maximumAge) throws SQLException {
+    final long timestamp = Instant.now()
+      .minus(maximumAge, ChronoUnit.DAYS)
+      .getEpochSecond() * 1000L; // convert to ms
+
+    final List<VerifiedPlayer> oldEntries = queryBuilder.where()
+      .lt("timestamp", new Timestamp(timestamp))
+      .query();
+
+    if (oldEntries != null) {
+      for (final VerifiedPlayer player : oldEntries) {
+        dao.delete(player);
+      }
+      LOGGER.info("Removed {} database entries older than {} days.",
+        oldEntries.size(), maximumAge);
     }
   }
 
@@ -87,12 +165,16 @@ public final class VerifiedPlayerController {
     _remove(inetAddress);
 
     // Don't try to update the column if the database type is NONE
-    if (cachedDatabaseType == SonarConfiguration.DatabaseType.NONE) {
+    if (cachedDatabaseType == SonarConfiguration.Database.Type.NONE) {
       return;
     }
 
     DB_UPDATE_SERVICE.execute(() -> {
-      Objects.requireNonNull(connectionSource);
+      // We cannot throw a NullPointerException within the executor service
+      // because we want to handle the error instead of simply throwing an exception
+      if (connectionSource == null) {
+        return;
+      }
 
       try {
         final List<VerifiedPlayer> verifiedPlayer = queryBuilder.where()
@@ -105,7 +187,7 @@ public final class VerifiedPlayerController {
           }
         }
       } catch (SQLException exception) {
-        Sonar.get().getLogger().error("Error trying to remove entry: {}", exception);
+        LOGGER.error("Error trying to remove entry: {}", exception);
       }
     });
   }
@@ -129,17 +211,21 @@ public final class VerifiedPlayerController {
     _add(player);
 
     // Don't try to update the column if the database type is NONE
-    if (cachedDatabaseType == SonarConfiguration.DatabaseType.NONE) {
+    if (cachedDatabaseType == SonarConfiguration.Database.Type.NONE) {
       return;
     }
 
     DB_UPDATE_SERVICE.execute(() -> {
-      Objects.requireNonNull(connectionSource);
+      // We cannot throw a NullPointerException within the executor service
+      // because we want to handle the error instead of simply throwing an exception
+      if (connectionSource == null) {
+        return;
+      }
 
       try {
         dao.create(player);
       } catch (SQLException exception) {
-        Sonar.get().getLogger().error("Error trying to add entry: {}", exception);
+        LOGGER.error("Error trying to add entry: {}", exception);
       }
     });
   }
@@ -179,11 +265,11 @@ public final class VerifiedPlayerController {
       MAP.clear();
 
       // Only update the column if the database type is not NONE
-      if (cachedDatabaseType != SonarConfiguration.DatabaseType.NONE) {
+      if (cachedDatabaseType != SonarConfiguration.Database.Type.NONE) {
         dao.deleteBuilder().delete();
       }
     } catch (SQLException exception) {
-      Sonar.get().getLogger().error("Error trying to clear entries: {}", exception);
+      LOGGER.error("Error trying to clear entries: {}", exception);
     }
   }
 

sonar-api/src/main/java/xyz/jonesdev/sonar/api/dependencies/Dependency.java

@@ -1,91 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.api.dependencies;
-
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.timer.SystemTimer;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
-
-// Mostly taken from
-// https://github.com/Elytrium/LimboAuth/blob/master/src/main/java/net/elytrium/limboauth/dependencies/BaseLibrary.java
-public enum Dependency {
-  // https://mvnrepository.com/artifact/com.mysql/mysql-connector-j
-  MYSQL(
-    "com/mysql",
-    "mysql-connector-j",
-    "8.1.0"
-  ),
-  // https://mvnrepository.com/artifact/org.mariadb.jdbc/mariadb-java-client
-  MARIADB(
-    "org/mariadb/jdbc",
-    "mariadb-java-client",
-    "3.1.4"
-  );
-
-  private @NotNull
-  final Path tempFilePath;
-  private @NotNull
-  final URL mvnRepoURL;
-
-  Dependency(final @NotNull String groupId,
-             final @NotNull String artifactId,
-             final @NotNull String version) {
-    final String archiveFileName = String.format("%s-%s.jar", artifactId, version);
-    this.tempFilePath = new File(Sonar.get().getDataDirectory(), "libraries/" + archiveFileName).toPath();
-
-    try {
-      final String mvnCentralPath = String.format("%s/%s/%s/%s-%s.jar",
-        groupId, artifactId, version, artifactId, version);
-
-      this.mvnRepoURL = new URL("https://repo1.maven.org/maven2/" + mvnCentralPath);
-    } catch (MalformedURLException exception) {
-      throw new IllegalStateException(exception);
-    }
-  }
-
-  /**
-   * @return URL for the local file used for the external URLClassLoader
-   */
-  public @NotNull URL getClassLoaderURL() throws MalformedURLException {
-    if (!Files.exists(tempFilePath)) {
-      final SystemTimer timer = new SystemTimer();
-      Sonar.get().getLogger().info("Downloading dependency {}...", tempFilePath.getFileName());
-
-      try (final InputStream inputStream = mvnRepoURL.openStream()) {
-        Files.createDirectories(tempFilePath.getParent());
-        Files.copy(inputStream, Files.createFile(tempFilePath), REPLACE_EXISTING);
-      } catch (IOException exception) {
-        throw new IllegalStateException(exception);
-      }
-
-      Sonar.get().getLogger().info("Finished downloading {} ({}s)!", tempFilePath.getFileName(), timer);
-    }
-
-    return tempFilePath.toUri().toURL();
-  }
-}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/dependencies/DependencyLoader.java

@@ -1,84 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.api.dependencies;
-
-import com.j256.ormlite.jdbc.JdbcSingleConnectionSource;
-import com.j256.ormlite.support.ConnectionSource;
-import lombok.experimental.UtilityClass;
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.config.SonarConfiguration;
-
-import java.io.File;
-import java.lang.reflect.Method;
-import java.net.URL;
-import java.nio.file.Path;
-import java.sql.Connection;
-import java.sql.Driver;
-import java.sql.DriverManager;
-import java.util.Properties;
-
-@UtilityClass
-public class DependencyLoader {
-  public ConnectionSource setUpDriverAndConnect() throws Throwable {
-    final SonarConfiguration config = Sonar.get().getConfig();
-
-    final URL[] urls = new URL[config.getDatabaseType().getDependencies().length];
-    for (final Dependency dependency : config.getDatabaseType().getDependencies()) {
-      final URL url = dependency.getClassLoaderURL();
-      final ClassLoader currentClassLoader = DependencyLoader.class.getClassLoader();
-
-      final Method addPath = currentClassLoader.getClass().getDeclaredMethod("addPath", Path.class);
-      addPath.setAccessible(true);
-      addPath.invoke(currentClassLoader, new File(url.toURI()).toPath());
-
-      urls[dependency.ordinal()] = url;
-    }
-
-    final String type = config.getDatabaseType().name().toLowerCase();
-    final String databaseURL =
-      "jdbc:" + type + "://" + config.getSqlUrl() + ":" + config.getSqlPort() + "/" + config.getSqlDatabase();
-
-    final ExternalClassLoader classLoader = new ExternalClassLoader(urls);
-    final Connection connection = connect(classLoader, databaseURL, config);
-    return new JdbcSingleConnectionSource(databaseURL, connection);
-  }
-
-  // Mostly taken from
-  // https://github.com/Elytrium/LimboAuth/blob/master/src/main/java/net/elytrium/limboauth/dependencies/DatabaseLibrary.java#L134
-  private Connection connect(final @NotNull ClassLoader classLoader,
-                             final @NotNull String databaseURL,
-                             final @NotNull SonarConfiguration configuration) throws Throwable {
-    final Class<?> driverClass = classLoader.loadClass(configuration.getDatabaseType().getDriverClassName());
-    final Object driver = driverClass.getDeclaredConstructor().newInstance();
-
-    DriverManager.registerDriver((Driver) driver);
-
-    final Properties properties = new Properties();
-    if (!configuration.getSqlUser().isEmpty()) {
-      properties.put("user", configuration.getSqlUser());
-    }
-    if (!configuration.getSqlPassword().isEmpty()) {
-      properties.put("password", configuration.getSqlPassword());
-    }
-
-    final Method connect = driverClass.getDeclaredMethod("connect", String.class, Properties.class);
-    connect.setAccessible(true);
-    return (Connection) connect.invoke(driver, databaseURL, properties);
-  }
-}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/event/SonarEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-api/src/main/java/xyz/jonesdev/sonar/api/event/SonarEventListener.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-api/src/main/java/xyz/jonesdev/sonar/api/event/SonarEventManager.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,24 +21,40 @@ import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
 
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Vector;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
 public final class SonarEventManager {
   public static final SonarEventManager INSTANCE = new SonarEventManager();
   private static final Collection<SonarEventListener> EVENT_LISTENERS = new Vector<>(0);
+  private static final ExecutorService EVENT_SERVICE = Executors.newSingleThreadExecutor();
 
   /**
    * Publishes the given event to all listeners
    */
   @ApiStatus.Internal
   public void publish(final @NotNull SonarEvent event) {
-    for (final SonarEventListener eventListener : EVENT_LISTENERS) {
-      eventListener.handle(event);
+    // Don't post a task if there are no listeners
+    if (EVENT_LISTENERS.isEmpty()) {
+      return;
     }
+
+    EVENT_SERVICE.execute(() -> {
+      for (final SonarEventListener eventListener : EVENT_LISTENERS) {
+        try {
+          eventListener.handle(event);
+        } catch (Throwable throwable) {
+          Sonar.get().getLogger().error("Could not pass {} to listener: {}",
+            event.getClass().getSimpleName(), throwable);
+        }
+      }
+    });
   }
 
   /**
@@ -47,6 +63,7 @@ public final class SonarEventManager {
    * @param listeners One (or more) listeners to register
    * @see #unregisterListener(SonarEventListener...) Unregister an event listener
    */
+  @SuppressWarnings("unused") // External API usage
   public synchronized void registerListener(final @NotNull SonarEventListener... listeners) {
     EVENT_LISTENERS.addAll(Arrays.asList(listeners));
   }
@@ -58,6 +75,7 @@ public final class SonarEventManager {
    * @apiNote This does not have any effect if the given listeners are not registered
    * @see #registerListener(SonarEventListener...) Register an event listener
    */
+  @SuppressWarnings("unused") // External API usage
   public synchronized void unregisterListener(final @NotNull SonarEventListener... listeners) {
     EVENT_LISTENERS.removeAll(Arrays.asList(listeners));
   }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/event/impl/AttackDetectedEvent.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.event.impl;
+
+import xyz.jonesdev.sonar.api.event.SonarEvent;
+
+public final class AttackDetectedEvent implements SonarEvent {
+}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/event/impl/AttackMitigatedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,28 +15,19 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.server;
+package xyz.jonesdev.sonar.api.event.impl;
 
+import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
-import xyz.jonesdev.sonar.api.SonarPlatform;
-import xyz.jonesdev.sonar.api.command.InvocationSource;
-
-import java.util.Optional;
+import lombok.ToString;
+import xyz.jonesdev.sonar.api.attack.AttackTracker;
+import xyz.jonesdev.sonar.api.event.SonarEvent;
 
 @Getter
+@ToString
+@EqualsAndHashCode
 @RequiredArgsConstructor
-public abstract class ServerWrapper {
-
-  /**
-   * Platform of the server (Velocity, BungeeCord, Spigot)
-   */
-  private final SonarPlatform platform;
-
-  /**
-   * @param username Username of the player
-   * @return Optional player wrapped as InvocationSender
-   * @see InvocationSource
-   */
-  public abstract Optional<InvocationSource> getOnlinePlayer(final String username);
+public final class AttackMitigatedEvent implements SonarEvent {
+  private final AttackTracker.AttackStatistics attackStatistics;
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/event/impl/UserBlacklistedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -31,5 +31,5 @@ import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 @RequiredArgsConstructor
 public final class UserBlacklistedEvent implements SonarEvent {
   @ApiStatus.Experimental
-  private final FallbackUser<?, ?> user;
+  private final FallbackUser user;
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/event/impl/UserVerifyFailedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,16 +19,23 @@ package xyz.jonesdev.sonar.api.event.impl;
 
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
-import lombok.RequiredArgsConstructor;
 import lombok.ToString;
+import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.event.SonarEvent;
 import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 
+import java.util.Optional;
+
 @Getter
 @ToString
 @EqualsAndHashCode
-@RequiredArgsConstructor
 public final class UserVerifyFailedEvent implements SonarEvent {
-  private final FallbackUser<?, ?> user;
-  private final String reason;
+  private final FallbackUser user;
+  @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
+  private final Optional<String> reason;
+
+  public UserVerifyFailedEvent(final FallbackUser user, final @Nullable String reason) {
+    this.user = user;
+    this.reason = Optional.ofNullable(reason);
+  }
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/event/impl/UserVerifyJoinEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -30,5 +30,5 @@ import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 @RequiredArgsConstructor
 public final class UserVerifyJoinEvent implements SonarEvent {
   private final String username;
-  private final FallbackUser<?, ?> user;
+  private final FallbackUser user;
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/event/impl/UserVerifySuccessEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -33,6 +33,6 @@ import java.util.UUID;
 public final class UserVerifySuccessEvent implements SonarEvent {
   private final String username;
   private final UUID offlineUuid;
-  private final FallbackUser<?, ?> user;
+  private final FallbackUser user;
   private final long timeTakenToVerify;
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/fallback/Fallback.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,20 +17,20 @@
 
 package xyz.jonesdev.sonar.api.fallback;
 
+import com.github.benmanes.caffeine.cache.Cache;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.Setter;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.cappuccino.Cappuccino;
-import xyz.jonesdev.cappuccino.ExpiringCache;
 import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.config.SonarConfiguration;
 import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
 
 import java.net.InetAddress;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.TimeUnit;
 
 @Getter
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
@@ -38,11 +38,14 @@ public final class Fallback {
   public static final Fallback INSTANCE = new Fallback();
   private static final @NotNull Sonar SONAR = Objects.requireNonNull(Sonar.get());
 
-  private final Map<String, InetAddress> connected = new ConcurrentHashMap<>();
-  // Only block the player for a few minutes to avoid issues
-  private final ExpiringCache<String> blacklisted = Cappuccino.buildExpiring(
-    10L, TimeUnit.MINUTES, 2500L
-  );
+  // Map of all connected usernames and their respective IP addresses (used for fast checking)
+  private final Map<String, InetAddress> connected = new ConcurrentHashMap<>(64, 0.75f);
+  // Cache of all blacklisted IP addresses to ensure each entry can expire after the given time
+  @Setter
+  private Cache<InetAddress, Byte> blacklist;
+  @Setter
+  private long blacklistTime;
+
   private final @NotNull FallbackQueue queue = FallbackQueue.INSTANCE;
   private final @NotNull FallbackRatelimiter ratelimiter = FallbackRatelimiter.INSTANCE;
 
@@ -50,22 +53,32 @@ public final class Fallback {
 
     @Override
     public void info(final String message, final Object... args) {
-      SONAR.getLogger().info("[Fallback] " + message, args);
+      SONAR.getLogger().info("[fallback] " + message, args);
     }
 
     @Override
     public void warn(final String message, final Object... args) {
-      SONAR.getLogger().warn("[Fallback] " + message, args);
+      SONAR.getLogger().warn("[fallback] " + message, args);
     }
 
     @Override
     public void error(final String message, final Object... args) {
-      SONAR.getLogger().error("[Fallback] " + message, args);
+      SONAR.getLogger().error("[fallback] " + message, args);
     }
   };
 
-  public boolean isPotentiallyUnderAttack() {
-    return connected.size() > SONAR.getConfig().getMinimumPlayersForAttack()
-      || queue.getQueuedPlayers().size() > SONAR.getConfig().getMinimumPlayersForAttack();
+  @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+  public boolean shouldVerifyNewPlayers() {
+    return performTimingCheck(Sonar.get().getConfig().getVerification().getTiming());
+  }
+
+  public boolean shouldDoMapCaptcha() {
+    return performTimingCheck(Sonar.get().getConfig().getVerification().getMap().getTiming());
+  }
+
+  private boolean performTimingCheck(final SonarConfiguration.Verification.Timing timing) {
+    return timing == SonarConfiguration.Verification.Timing.ALWAYS
+      || (timing == SonarConfiguration.Verification.Timing.DURING_ATTACK
+      && Sonar.get().getAttackTracker().isCurrentlyUnderAttack());
   }
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/fallback/FallbackPipelines.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,6 +21,5 @@ public interface FallbackPipelines {
   String FALLBACK_HANDLER = "sonar-fallback-handler";
   String FALLBACK_PACKET_ENCODER = "sonar-fallback-encoder";
   String FALLBACK_PACKET_DECODER = "sonar-fallback-decoder";
-  String FALLBACK_IN_TRAFFIC = "sonar-traffic-in";
-  String FALLBACK_OUT_TRAFFIC = "sonar-traffic-out";
+  String FALLBACK_BANDWIDTH = "sonar-fallback-bandwidth";
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/fallback/FallbackQueue.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -30,8 +30,33 @@ import java.util.concurrent.ConcurrentHashMap;
 @Getter
 @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
 public final class FallbackQueue {
-  public static final FallbackQueue INSTANCE = new FallbackQueue();
-  private final Map<InetAddress, Runnable> queuedPlayers = new ConcurrentHashMap<>(16, 0.5f);
+  static final FallbackQueue INSTANCE = new FallbackQueue();
+  private final Map<InetAddress, Runnable> queuedPlayers = new ConcurrentHashMap<>(64);
+
+  // Runnable task executed for polling the queue
+  private final Runnable pollTask = () -> {
+    final int maxQueuePolls = Sonar.get().getConfig().getQueue().getMaxQueuePolls();
+    int index = 0;
+
+    // We need to be cautious here since we don't want any concurrency issues.
+    final Iterator<Map.Entry<InetAddress, Runnable>> iterator = queuedPlayers.entrySet().iterator();
+    while (iterator.hasNext()) {
+      // Break if we reached our maximum entries
+      if (++index > maxQueuePolls) {
+        break;
+      }
+      // Run the cached runnable
+      final Map.Entry<InetAddress, Runnable> entry = iterator.next();
+      entry.getValue().run();
+      // Remove runnable from iterator
+      iterator.remove();
+    }
+
+    // Run the attack check task
+    Sonar.get().getAttackTracker().checkIfUnderAttack();
+    // Clean up the cache of rate-limited IPs
+    Sonar.get().getFallback().getRatelimiter().cleanUpCache();
+  };
 
   /**
    * @param inetAddress IP address of the player
@@ -48,23 +73,4 @@ public final class FallbackQueue {
   public void remove(final InetAddress inetAddress) {
     queuedPlayers.remove(inetAddress);
   }
-
-  public void poll() {
-    final int max = Sonar.get().getConfig().getMaximumQueuePolls();
-    int index = 0;
-
-    // We need to be very careful here since we don't want any concurrency issues.
-    final Iterator<Map.Entry<InetAddress, Runnable>> iterator = queuedPlayers.entrySet().iterator();
-    while (iterator.hasNext()) {
-      // Break if we reached our maximum entries
-      if (++index > max) {
-        break;
-      }
-      // Run the cached runnable
-      final Map.Entry<InetAddress, Runnable> entry = iterator.next();
-      entry.getValue().run();
-      // Remove runnable from iterator
-      iterator.remove();
-    }
-  }
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/fallback/FallbackRatelimiter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,19 +17,28 @@
 
 package xyz.jonesdev.sonar.api.fallback;
 
+import com.github.benmanes.caffeine.cache.Cache;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.cappuccino.ExpiringCache;
 
 import java.net.InetAddress;
 
+@Setter
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
 public final class FallbackRatelimiter {
-  public static final FallbackRatelimiter INSTANCE = new FallbackRatelimiter();
-  @Setter
-  private ExpiringCache<InetAddress> expiringCache;
+  static final FallbackRatelimiter INSTANCE = new FallbackRatelimiter();
+  private Cache<InetAddress, Byte> expiringCache;
+
+  /**
+   * We don't want to clean up the cache in the
+   * {@link #attempt(InetAddress)} method because
+   * it would take up too many resources.
+   */
+  public void cleanUpCache() {
+    expiringCache.cleanUp();
+  }
 
   /**
    * Checks if the player has tried verifying too fast
@@ -37,13 +46,12 @@ public final class FallbackRatelimiter {
    * @param inetAddress IP address of the player
    * @return Whether the player is allowed to verify
    */
+  @SuppressWarnings("BooleanMethodIsAlwaysInverted")
   public boolean attempt(final @NotNull InetAddress inetAddress) {
-    // Clean up the cache
-    expiringCache.cleanUp(false);
-
     // Cache the IP address if it's not already cached
-    if (!expiringCache.has(inetAddress)) {
-      expiringCache.put(inetAddress);
+    if (!expiringCache.asMap().containsKey(inetAddress)) {
+      // Cache the IP address
+      expiringCache.put(inetAddress, (byte) 0);
       return true;
     }
     // Deny the connection attempt

sonar-api/src/main/java/xyz/jonesdev/sonar/api/fallback/FallbackUser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,64 +17,107 @@
 
 package xyz.jonesdev.sonar.api.fallback;
 
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
 import io.netty.channel.Channel;
-import io.netty.channel.ChannelPipeline;
+import io.netty.util.ReferenceCountUtil;
 import net.kyori.adventure.text.Component;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import xyz.jonesdev.cappuccino.Cappuccino;
-import xyz.jonesdev.cappuccino.ExpiringCache;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.event.impl.UserBlacklistedEvent;
-import xyz.jonesdev.sonar.api.event.impl.UserVerifyFailedEvent;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
-import xyz.jonesdev.sonar.api.statistics.Statistics;
 
 import java.net.InetAddress;
-import java.util.concurrent.TimeUnit;
-
-public interface FallbackUser<X, Y> {
-  @NotNull Fallback getFallback();
-
-  @NotNull X getPlayer();
-
-  @NotNull Y getConnection();
+import java.time.Duration;
+import java.util.Objects;
+import java.util.UUID;
 
+public interface FallbackUser {
   @NotNull Channel getChannel();
 
-  @NotNull ChannelPipeline getPipeline();
-
   @NotNull InetAddress getInetAddress();
 
   @NotNull ProtocolVersion getProtocolVersion();
 
   /**
-   * Kicks the player from the server with
-   * the given disconnect message.
-   *
-   * @param reason Legacy disconnect message string
-   * @see #disconnect(Component)
-   */
-  default void disconnect(final @NotNull String reason) {
-    disconnect(Component.text(reason));
-  }
-
-  /**
-   * Kicks the player from the server with
-   * the given disconnect message.
+   * Disconnect the player during/after verification
+   * using our custom Disconnect packet.
    *
    * @param reason Disconnect message component
    */
   void disconnect(final @NotNull Component reason);
 
+  /**
+   * Takes over the channel and begins the verification process
+   *
+   * @param username Username of the player
+   * @param uuid     UUID of the player
+   * @param encoder  Name of the encoder pipeline
+   * @param decoder  Name of the decoder pipeline
+   * @param timeout  Name of the read timeout pipeline
+   * @param boss     Name of the main pipeline
+   */
+  void hijack(final @NotNull String username, final @NotNull UUID uuid,
+              final @NotNull String encoder, final @NotNull String decoder,
+              final @NotNull String timeout, final @NotNull String boss);
+
   /**
    * Sends a packet/message to the player
    *
    * @param msg Message to send to the player
    */
-  void write(final @NotNull Object msg);
+  default void write(final @NotNull Object msg) {
+    if (getChannel().isActive()) {
+      getChannel().writeAndFlush(msg, getChannel().voidPromise());
+    } else {
+      ReferenceCountUtil.release(msg);
+    }
+  }
 
-  ExpiringCache<String> PREVIOUS_FAILS = Cappuccino.buildExpiring(3L, TimeUnit.MINUTES);
+  /**
+   * Queues a buffered message that will be
+   * sent once all messages are flushed.
+   */
+  default void delayedWrite(final @NotNull Object msg) {
+    if (getChannel().isActive()) {
+      getChannel().write(msg, getChannel().voidPromise());
+    } else {
+      ReferenceCountUtil.release(msg);
+    }
+  }
+
+  Cache<InetAddress, Integer> GLOBAL_FAIL_COUNT = Caffeine.newBuilder()
+    .expireAfterWrite(Duration.ofMinutes(5)) // expire after 5 minutes
+    .build();
+
+  /**
+   * Increments the number of times this user (by IP address) has failed the verification
+   */
+  default void incrementFails() {
+    final InetAddress inetAddress = Objects.requireNonNull(getInetAddress());
+    final int failCount = getFailedCount();
+    // Make sure to remove the old values from the cache
+    if (failCount > 0) {
+      GLOBAL_FAIL_COUNT.invalidate(inetAddress);
+    }
+    GLOBAL_FAIL_COUNT.put(inetAddress, failCount + 1);
+  }
+
+  /**
+   * @return The number of times this user (by IP address) has failed the verification
+   * @apiNote Returns 0 if no key/value is present in the cache
+   */
+  default int getFailedCount() {
+    // Make sure to clean up the cache before we try to get cached values
+    GLOBAL_FAIL_COUNT.cleanUp();
+    return GLOBAL_FAIL_COUNT.asMap().getOrDefault(Objects.requireNonNull(getInetAddress()), 0);
+  }
+
+  /**
+   * Removes all previously failed verifications
+   */
+  default void invalidateFails() {
+    GLOBAL_FAIL_COUNT.invalidate(Objects.requireNonNull(getInetAddress()));
+  }
 
   /**
    * Disconnects the player who failed the verification
@@ -84,38 +127,5 @@ public interface FallbackUser<X, Y> {
    *
    * @param reason Reason for failing the verification
    */
-  default void fail(final @Nullable String reason) {
-    if (getChannel().isActive()) {
-      // Call the VerifyFailedEvent for external API usage
-      Sonar.get().getEventManager().publish(new UserVerifyFailedEvent(this, reason));
-
-      disconnect(Sonar.get().getConfig().getVerificationFailed());
-
-      if (reason != null) {
-        getFallback().getLogger().info(Sonar.get().getConfig().getVerificationFailedLog()
-          .replace("%ip%", Sonar.get().getConfig().formatAddress(getInetAddress()))
-          .replace("%protocol%", String.valueOf(getProtocolVersion().getProtocol()))
-          .replace("%reason%", reason));
-      }
-    }
-
-    Statistics.FAILED_VERIFICATIONS.increment();
-
-    // Make sure old entries are removed
-    PREVIOUS_FAILS.cleanUp();
-
-    // Check if the player has too many failed attempts
-    if (PREVIOUS_FAILS.has(getInetAddress().toString())) {
-      // Call the BotBlacklistedEvent for external API usage
-      Sonar.get().getEventManager().publish(new UserBlacklistedEvent(this));
-
-      getFallback().getBlacklisted().put(getInetAddress().toString());
-      getFallback().getLogger().info(Sonar.get().getConfig().getVerificationBlacklistLog()
-        .replace("%ip%", Sonar.get().getConfig().formatAddress(getInetAddress()))
-        .replace("%protocol%", String.valueOf(getProtocolVersion().getProtocol())));
-    } else {
-      // Cache the InetAddress for 3 minutes
-      PREVIOUS_FAILS.put(getInetAddress().toString());
-    }
-  }
+  void fail(final @Nullable String reason);
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/fallback/protocol/ProtocolVersion.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,6 +17,7 @@
 
 package xyz.jonesdev.sonar.api.fallback.protocol;
 
+import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 
 import java.util.EnumSet;
@@ -24,10 +25,10 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 
+@Getter
 @RequiredArgsConstructor
 public enum ProtocolVersion {
   UNKNOWN(-1),
-  LEGACY(-2),
   MINECRAFT_1_7_2(4),
   MINECRAFT_1_7_6(5),
   MINECRAFT_1_8(47),
@@ -66,14 +67,13 @@ public enum ProtocolVersion {
   MINECRAFT_1_19_3(761),
   MINECRAFT_1_19_4(762),
   MINECRAFT_1_20(763),
-  MINECRAFT_1_20_2(-1);
+  MINECRAFT_1_20_2(764),
+  MINECRAFT_1_20_3(765);
 
   private final int protocol;
-  private final int snapshotProtocol = -1;
 
-  public static final ProtocolVersion MINIMUM_VERSION = MINECRAFT_1_7_2;
+  public static final ProtocolVersion LATEST_VERSION;
   public static final Map<Integer, ProtocolVersion> ID_TO_PROTOCOL_CONSTANT;
-  public static final Set<ProtocolVersion> SUPPORTED_VERSIONS;
 
   static {
     {
@@ -81,7 +81,6 @@ public enum ProtocolVersion {
 
       for (final ProtocolVersion version : values()) {
         versions.putIfAbsent(version.protocol, version);
-        versions.put(version.snapshotProtocol, version);
       }
 
       ID_TO_PROTOCOL_CONSTANT = versions;
@@ -91,12 +90,12 @@ public enum ProtocolVersion {
       final Set<ProtocolVersion> versions = EnumSet.noneOf(ProtocolVersion.class);
 
       for (final ProtocolVersion value : values()) {
-        if (!value.isUnknown() && !value.isLegacy()) {
+        if (!value.isUnknown()) {
           versions.add(value);
         }
       }
 
-      SUPPORTED_VERSIONS = versions;
+      LATEST_VERSION = (ProtocolVersion) versions.toArray()[versions.size() - 1];
     }
   }
 
@@ -104,15 +103,11 @@ public enum ProtocolVersion {
     return ID_TO_PROTOCOL_CONSTANT.getOrDefault(protocol, UNKNOWN);
   }
 
-  public int getProtocol() {
-    return protocol == -1 ? snapshotProtocol : protocol;
+  public boolean inBetween(final ProtocolVersion first, final ProtocolVersion last) {
+    return compareTo(first) >= 0 && compareTo(last) <= 0;
   }
 
   public boolean isUnknown() {
     return this == UNKNOWN;
   }
-
-  public boolean isLegacy() {
-    return this == LEGACY;
-  }
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/jvm/JVMProcessInformation.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.jvm;
+
+import com.sun.management.OperatingSystemMXBean;
+import lombok.experimental.UtilityClass;
+
+import java.lang.management.ManagementFactory;
+
+@UtilityClass
+public class JVMProcessInformation {
+  private final Runtime RUNTIME = Runtime.getRuntime();
+  private final OperatingSystemMXBean MX = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
+  private final char[] MEMORY_UNITS = {'K', 'M', 'G', 'T', 'P', 'E'};
+
+  public String formatMemory(final long size) {
+    if (size < 1024L) {
+      return size + " B";
+    }
+    final int group = (63 - Long.numberOfLeadingZeros(size)) / 10;
+    final double formattedSize = (double) size / (1L << (group * 10));
+    final char unit = MEMORY_UNITS[group - 1];
+    // https://en.wikipedia.org/wiki/Byte#Multiple-byte_units
+    return String.format("%.1f %siB", formattedSize, unit);
+  }
+
+  public int getVirtualCores() {
+    return RUNTIME.availableProcessors();
+  }
+
+  public double getProcessCPUUsage() {
+    return MX.getProcessCpuLoad() * 100;
+  }
+
+  public double getAverageProcessCPUUsage() {
+    return getProcessCPUUsage() / getVirtualCores();
+  }
+
+  public double getSystemCPUUsage() {
+    return MX.getSystemCpuLoad() * 100;
+  }
+
+  public double getAverageSystemCPUUsage() {
+    return getSystemCPUUsage() / getVirtualCores();
+  }
+
+  public double getSystemLoadAverage() {
+    return MX.getSystemLoadAverage() * 100;
+  }
+
+  public long getMaxMemory() {
+    return RUNTIME.maxMemory();
+  }
+
+  public long getTotalMemory() {
+    return RUNTIME.totalMemory();
+  }
+
+  public long getFreeMemory() {
+    return RUNTIME.freeMemory();
+  }
+
+  public long getUsedMemory() {
+    return getTotalMemory() - getFreeMemory();
+  }
+}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/logger/LoggerWrapper.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,6 +17,10 @@
 
 package xyz.jonesdev.sonar.api.logger;
 
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.Array;
+
 /**
  * The whole purpose of doing this is, so we can have one logger for every module.
  * We wouldn't need to get the plugin logger every time we try to use it.
@@ -28,4 +32,62 @@ public interface LoggerWrapper {
   void warn(final String message, final Object... args);
 
   void error(final String message, final Object... args);
+
+  // Taken from
+  // https://github.com/j256/ormlite-core/blob/master/src/main/java/com/j256/ormlite/logger/Logger.java
+  String ARG_STRING = "{}";
+  int ARG_STRING_LENGTH = ARG_STRING.length();
+  Object UNKNOWN_ARG = new Object();
+
+  default String buildFullMessage(final @NotNull String msg, final Object... args) {
+    StringBuilder sb = null;
+    int lastIndex = 0;
+    int argC = 0;
+    while (true) {
+      int argIndex = msg.indexOf(ARG_STRING, lastIndex);
+      // no more {} arguments?
+      if (argIndex == -1) {
+        break;
+      }
+      if (sb == null) {
+        // we build this lazily in case there is no {} in the msg
+        sb = new StringBuilder(128);
+      }
+      // add the string before the arg-string
+      sb.append(msg, lastIndex, argIndex);
+      // shift our last-index past the arg-string
+      lastIndex = argIndex + ARG_STRING_LENGTH;
+      // add the arguments
+      if (argC < args.length) {
+        appendArg(sb, args[argC]);
+      }
+      argC++;
+    }
+    if (sb == null) {
+      return msg;
+    } else {
+      sb.append(msg, lastIndex, msg.length());
+      return sb.toString();
+    }
+  }
+
+  default void appendArg(final StringBuilder stringBuilder, final Object arg) {
+    if (arg == UNKNOWN_ARG) {
+      // ignore it
+    } else if (arg == null) {
+      stringBuilder.append("null");
+    } else if (arg.getClass().isArray()) {
+      stringBuilder.append('[');
+      int length = Array.getLength(arg);
+      for (int i = 0; i < length; i++) {
+        if (i > 0) {
+          stringBuilder.append(", ");
+        }
+        appendArg(stringBuilder, Array.get(arg, i));
+      }
+      stringBuilder.append(']');
+    } else {
+      stringBuilder.append(arg);
+    }
+  }
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/model/VerifiedPlayer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,12 +24,13 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.ToString;
 
+import java.sql.Timestamp;
 import java.util.UUID;
 
 @Getter
 @ToString
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
-@DatabaseTable(tableName = "verified_players")
+@DatabaseTable(tableName = "sonar_verified_players")
 public final class VerifiedPlayer {
   @SuppressWarnings("unused")
   @DatabaseField(generatedId = true)
@@ -51,12 +52,15 @@ public final class VerifiedPlayer {
   )
   private UUID playerUUID;
 
-  @DatabaseField(columnName = "timestamp", canBeNull = false)
-  private long timestamp;
+  @DatabaseField(
+    columnName = "timestamp",
+    canBeNull = false
+  )
+  private Timestamp timestamp;
 
   public VerifiedPlayer(final String inetAddress, final UUID playerUUID, final long timestamp) {
     this.inetAddress = inetAddress;
     this.playerUUID = playerUUID;
-    this.timestamp = timestamp;
+    this.timestamp = new Timestamp(timestamp);
   }
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/ormlite/MariaDbDatabaseTypeAdapter.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.ormlite;
+
+import com.j256.ormlite.jdbc.db.MariaDbDatabaseType;
+import org.jetbrains.annotations.NotNull;
+
+public final class MariaDbDatabaseTypeAdapter extends MariaDbDatabaseType {
+
+  @Override
+  protected String @NotNull [] getDriverClassNames() {
+    return new String[]{"xyz.jonesdev.sonar.libs.mariadb.jdbc.Driver"};
+  }
+}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/ormlite/MysqlDatabaseTypeAdapter.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.ormlite;
+
+import com.j256.ormlite.jdbc.db.MysqlDatabaseType;
+import org.jetbrains.annotations.NotNull;
+
+public final class MysqlDatabaseTypeAdapter extends MysqlDatabaseType {
+
+  @Override
+  protected String @NotNull [] getDriverClassNames() {
+    return new String[]{"xyz.jonesdev.sonar.libs.mysql.cj.jdbc.Driver"};
+  }
+}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/profiler/JVMProfiler.java

@@ -1,75 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.api.profiler;
-
-import com.sun.management.OperatingSystemMXBean;
-
-import java.lang.management.ManagementFactory;
-import java.lang.management.RuntimeMXBean;
-
-public interface JVMProfiler {
-  Runtime RUNTIME = Runtime.getRuntime();
-  OperatingSystemMXBean OPERATING_SYSTEM_MX_BEAN = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
-  RuntimeMXBean RUNTIME_MX_BEAN = ManagementFactory.getRuntimeMXBean();
-
-  default String formatMemory(final long m) {
-    if (m < 1024L) return m + " B";
-    final int z = (63 - Long.numberOfLeadingZeros(m)) / 10;
-    return String.format("%.1f %sB", (double) m / (1L << (z * 10)), " KMGTPE".charAt(z));
-  }
-
-  default int getVirtualCores() {
-    return RUNTIME.availableProcessors();
-  }
-
-  default double getProcessCPUUsage() {
-    return OPERATING_SYSTEM_MX_BEAN.getProcessCpuLoad() * 100;
-  }
-
-  default double getAverageProcessCPUUsage() {
-    return getProcessCPUUsage() / getVirtualCores();
-  }
-
-  default double getSystemCPUUsage() {
-    return OPERATING_SYSTEM_MX_BEAN.getSystemCpuLoad() * 100;
-  }
-
-  default double getAverageSystemCPUUsage() {
-    return getSystemCPUUsage() / getVirtualCores();
-  }
-
-  default double getSystemLoadAverage() {
-    return OPERATING_SYSTEM_MX_BEAN.getSystemLoadAverage() * 100;
-  }
-
-  default long getMaxMemory() {
-    return RUNTIME.maxMemory();
-  }
-
-  default long getTotalMemory() {
-    return RUNTIME.totalMemory();
-  }
-
-  default long getFreeMemory() {
-    return RUNTIME.freeMemory();
-  }
-
-  default long getUsedMemory() {
-    return getTotalMemory() - getFreeMemory();
-  }
-}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/statistics/SonarStatistics.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.statistics;
+
+import org.jetbrains.annotations.ApiStatus;
+
+public interface SonarStatistics {
+  long getConnectionsPerSecond();
+
+  long getLoginsPerSecond();
+
+  long getCurrentIncomingBandwidth();
+
+  long getCurrentOutgoingBandwidth();
+
+  long getTotalIncomingBandwidth();
+
+  long getTotalOutgoingBandwidth();
+
+  String getCurrentIncomingBandwidthFormatted();
+
+  String getCurrentOutgoingBandwidthFormatted();
+
+  String getTotalIncomingBandwidthFormatted();
+
+  String getTotalOutgoingBandwidthFormatted();
+
+  int getTotalPlayersJoined();
+
+  int getTotalPlayersVerified();
+
+  int getTotalSuccessfulVerifications();
+
+  int getTotalFailedVerifications();
+
+  long getCurrentAttemptedVerifications();
+
+  int getTotalAttemptedVerifications();
+
+  long getCurrentBlacklistSize();
+
+  long getTotalBlacklistSize();
+
+  @ApiStatus.Internal
+  void cleanUpCache();
+}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/statistics/Statistics.java

@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.api.statistics;
-
-public enum Statistics {
-  TOTAL_TRAFFIC,
-  REAL_TRAFFIC,
-  FAILED_VERIFICATIONS;
-
-  private int val = -1;
-
-  /**
-   * Increments the current value by 1 with the default value of 0
-   *
-   * @see #get(int)
-   * @see #set(int)
-   */
-  public void increment() {
-    increment(0);
-  }
-
-  /**
-   * Increments the current value by 1 with a custom default value
-   *
-   * @see #get(int)
-   * @see #set(int)
-   */
-  public void increment(final int def) {
-    set(get(def) + 1);
-  }
-
-  /**
-   * @return The current value with the default value of 0
-   * @see #get(int)
-   */
-  public int get() {
-    return get(0);
-  }
-
-  /**
-   * @return The current value with a custom default value
-   */
-  public int get(final int def) {
-    return val == -1 ? def : val;
-  }
-
-  /**
-   * Set current value to a new value
-   */
-  public void set(final int value) {
-    val = value;
-  }
-}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/timer/SystemTimer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,9 +18,14 @@
 package xyz.jonesdev.sonar.api.timer;
 
 import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+import java.text.SimpleDateFormat;
 
 @Getter
 public final class SystemTimer {
+  private static final SimpleDateFormat FORMATTER = new SimpleDateFormat("mm:ss");
+
   private long start = System.currentTimeMillis();
 
   public void reset() {
@@ -35,6 +40,10 @@ public final class SystemTimer {
     return delay() >= amount;
   }
 
+  public @NotNull String formattedDelay() {
+    return FORMATTER.format(delay());
+  }
+
   @Override
   public String toString() {
     return String.format("%.3f", delay() / 1000D);

sonar-api/src/main/java/xyz/jonesdev/sonar/api/verbose/Notification.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.verbose;
+
+import lombok.Getter;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.title.Title;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.statistics.SonarStatistics;
+
+import java.util.Collection;
+import java.util.UUID;
+import java.util.Vector;
+
+import static xyz.jonesdev.sonar.api.Sonar.DECIMAL_FORMAT;
+
+@Getter
+public final class Notification implements Observable {
+  private final @NotNull Collection<UUID> subscribers = new Vector<>(0);
+
+  public void sendAttackNotification() {
+    // No need to do anything if we have no subscribers
+    if (subscribers.isEmpty()) return;
+    final SonarStatistics statistics = Sonar.get().getStatistics();
+    // Prepare the title
+    // TODO: Why do custom title times not work?
+    //  Title.Times.times(Ticks.duration(5L), Ticks.duration(60L), Ticks.duration(10L));
+    final Title title = Title.title(
+      Sonar.get().getConfig().getNotifications().getNotificationTitle(),
+      Sonar.get().getConfig().getNotifications().getNotificationSubtitle());
+    // Prepare the chat message
+    final Component chat = MiniMessage.miniMessage().deserialize(
+      Sonar.get().getConfig().getNotifications().getNotificationChat()
+        .replace("%queued%",
+          DECIMAL_FORMAT.format(Sonar.get().getFallback().getQueue().getQueuedPlayers().size()))
+        .replace("%verifying%", DECIMAL_FORMAT.format(Sonar.get().getFallback().getConnected().size()))
+        .replace("%blacklisted%",
+          DECIMAL_FORMAT.format(Sonar.get().getFallback().getBlacklist().estimatedSize()))
+        .replace("%total-joins%", DECIMAL_FORMAT.format(statistics.getTotalPlayersJoined()))
+        .replace("%logins-per-second%", DECIMAL_FORMAT.format(statistics.getLoginsPerSecond()))
+        .replace("%connections-per-second%", DECIMAL_FORMAT.format(statistics.getConnectionsPerSecond()))
+        .replace("%verify-total%", DECIMAL_FORMAT.format(statistics.getTotalAttemptedVerifications()))
+        .replace("%verify-success%",
+          DECIMAL_FORMAT.format(Sonar.get().getVerifiedPlayerController().estimatedSize()))
+        .replace("%verify-failed%", DECIMAL_FORMAT.format(statistics.getTotalFailedVerifications()))
+        .replace("%incoming-traffic%", statistics.getCurrentIncomingBandwidthFormatted())
+        .replace("%outgoing-traffic%", statistics.getCurrentOutgoingBandwidthFormatted())
+        .replace("%incoming-traffic-ttl%", statistics.getTotalIncomingBandwidthFormatted())
+        .replace("%outgoing-traffic-ttl%", statistics.getTotalOutgoingBandwidthFormatted()));
+    // Send the title and chat messages to all online players
+    for (final UUID subscriber : Sonar.get().getNotificationHandler().getSubscribers()) {
+      final Audience audience = Sonar.get().audience(subscriber);
+      if (audience == null) continue;
+      audience.showTitle(title);
+      audience.sendMessage(chat);
+    }
+  }
+}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/verbose/Observable.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.verbose;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.UUID;
+
+public interface Observable {
+  Collection<UUID> getSubscribers();
+
+  /**
+   * @param uuid UUID of the player
+   * @return Whether the audience is subscribed or not
+   */
+  default boolean isSubscribed(final @NotNull UUID uuid) {
+    return getSubscribers().contains(uuid);
+  }
+
+  /**
+   * @param uuid UUID of the player
+   */
+  default void subscribe(final UUID uuid) {
+    getSubscribers().add(uuid);
+  }
+
+  /**
+   * @param uuid UUID of the player
+   */
+  default void unsubscribe(final UUID uuid) {
+    getSubscribers().remove(uuid);
+  }
+}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/verbose/Verbose.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,98 +19,78 @@ package xyz.jonesdev.sonar.api.verbose;
 
 import lombok.Getter;
 import lombok.val;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.profiler.JVMProfiler;
-import xyz.jonesdev.sonar.api.statistics.Statistics;
+import xyz.jonesdev.sonar.api.attack.AttackTracker;
+import xyz.jonesdev.sonar.api.statistics.SonarStatistics;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
 
 import java.util.Collection;
+import java.util.UUID;
 import java.util.Vector;
 
 import static xyz.jonesdev.sonar.api.Sonar.DECIMAL_FORMAT;
-import static xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter.INCOMING;
-import static xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter.OUTGOING;
+import static xyz.jonesdev.sonar.api.jvm.JVMProcessInformation.*;
 
 @Getter
-public abstract class Verbose implements JVMProfiler {
-  protected final @NotNull Collection<String> subscribers = new Vector<>(0);
-  private final SystemTimer secondTimer = new SystemTimer();
-  protected int joinsPerSecond, totalJoins;
-  private int lastTotalJoins, animationIndex;
+public final class Verbose implements Observable {
+  private final @NotNull Collection<UUID> subscribers = new Vector<>(0);
+  private int animationIndex;
 
   // Run action bar verbose
-  public final void update() {
-    // Clean up all blacklisted IPs
-    Sonar.get().getFallback().getBlacklisted().cleanUp(false);
-
-    totalJoins = Statistics.TOTAL_TRAFFIC.get();
-
-    // Statistically determine the joins per second without any caches
-    if (totalJoins > 0 && secondTimer.elapsed(1000L)) {
-      secondTimer.reset();
-      joinsPerSecond = totalJoins - lastTotalJoins;
-      lastTotalJoins = totalJoins;
-    }
-
+  public void update() {
+    // Make sure to clean up the cached statistics
+    Sonar.get().getStatistics().cleanUpCache();
+    // Don't prepare component if there are no subscribers
+    if (subscribers.isEmpty()) return;
+    // Prepare the action bar format component
+    final Component component = prepareActionBarFormat();
     // Send the action bar to all online players
-    broadcast(prepareActionBarFormat());
+    for (final UUID subscriber : subscribers) {
+      final Audience audience = Sonar.get().audience(subscriber);
+      if (audience == null) continue;
+      audience.sendActionBar(component);
+    }
   }
 
-  protected @NotNull String prepareActionBarFormat() {
-    return Sonar.get().getConfig().getActionBarLayout()
+  public @NotNull Component prepareActionBarFormat() {
+    final SonarStatistics statistics = Sonar.get().getStatistics();
+    final AttackTracker.AttackStatistics attackStatistics = Sonar.get().getAttackTracker().getCurrentAttack();
+    final SystemTimer attackDuration = attackStatistics == null ? null : attackStatistics.getDuration();
+    return MiniMessage.miniMessage().deserialize((attackDuration != null
+      ? Sonar.get().getConfig().getVerbose().getActionBarLayoutDuringAttack()
+      : Sonar.get().getConfig().getVerbose().getActionBarLayout())
       .replace("%queued%",
         DECIMAL_FORMAT.format(Sonar.get().getFallback().getQueue().getQueuedPlayers().size()))
       .replace("%verifying%", DECIMAL_FORMAT.format(Sonar.get().getFallback().getConnected().size()))
       .replace("%blacklisted%",
-        DECIMAL_FORMAT.format(Sonar.get().getFallback().getBlacklisted().estimatedSize()))
-      .replace("%total-joins%", DECIMAL_FORMAT.format(totalJoins))
-      .replace("%per-second-joins%", DECIMAL_FORMAT.format(joinsPerSecond))
-      .replace("%verify-total%", DECIMAL_FORMAT.format(Statistics.REAL_TRAFFIC.get()))
+        DECIMAL_FORMAT.format(Sonar.get().getFallback().getBlacklist().estimatedSize()))
+      .replace("%blacklisted%", DECIMAL_FORMAT.format(statistics.getCurrentBlacklistSize()))
+      .replace("%total-joins%", DECIMAL_FORMAT.format(statistics.getTotalPlayersJoined()))
+      .replace("%logins-per-second%", DECIMAL_FORMAT.format(statistics.getLoginsPerSecond()))
+      .replace("%connections-per-second%", DECIMAL_FORMAT.format(statistics.getConnectionsPerSecond()))
+      .replace("%verify-total%", DECIMAL_FORMAT.format(statistics.getTotalAttemptedVerifications()))
       .replace("%verify-success%",
         DECIMAL_FORMAT.format(Sonar.get().getVerifiedPlayerController().estimatedSize()))
-      .replace("%verify-failed%", DECIMAL_FORMAT.format(Statistics.FAILED_VERIFICATIONS.get()))
-      .replace("%incoming-traffic%", INCOMING.getCachedSecond())
-      .replace("%outgoing-traffic%", OUTGOING.getCachedSecond())
-      .replace("%incoming-traffic-ttl%", INCOMING.getCachedTtl())
-      .replace("%outgoing-traffic-ttl%", OUTGOING.getCachedTtl())
+      .replace("%verify-failed%", DECIMAL_FORMAT.format(statistics.getTotalFailedVerifications()))
+      .replace("%attack-duration%", attackDuration == null ? "00:00" : attackDuration.formattedDelay())
+      .replace("%incoming-traffic%", statistics.getCurrentIncomingBandwidthFormatted())
+      .replace("%outgoing-traffic%", statistics.getCurrentOutgoingBandwidthFormatted())
+      .replace("%incoming-traffic-ttl%", statistics.getTotalIncomingBandwidthFormatted())
+      .replace("%outgoing-traffic-ttl%", statistics.getTotalOutgoingBandwidthFormatted())
       .replace("%used-memory%", formatMemory(getUsedMemory()))
       .replace("%free-memory%", formatMemory(getFreeMemory()))
       .replace("%total-memory%", formatMemory(getTotalMemory()))
       .replace("%max-memory%", formatMemory(getMaxMemory()))
-      .replace("%animation%", nextAnimation());
+      .replace("%animation%", nextAnimation()));
   }
 
-  protected final String nextAnimation() {
-    val animations = Sonar.get().getConfig().getAnimation();
+  public String nextAnimation() {
+    val animations = Sonar.get().getConfig().getVerbose().getAnimation();
     final int nextIndex = ++animationIndex % animations.size();
     return animations.toArray(new String[0])[nextIndex];
   }
-
-  // Run action bar verbose
-  protected void broadcast(final String message) {
-    // This should be replaced by the wrapper
-  }
-
-  /**
-   * @param subscriber Name of the player who subscribed
-   * @return Whether the player is subscribed or not
-   */
-  public final boolean isSubscribed(final @NotNull String subscriber) {
-    return subscribers.contains(subscriber);
-  }
-
-  /**
-   * @param subscriber Name of the player to subscribe
-   */
-  public final void subscribe(final @NotNull String subscriber) {
-    subscribers.add(subscriber);
-  }
-
-  /**
-   * @param subscriber Name of the player to unsubscribe
-   */
-  public final void unsubscribe(final @NotNull String subscriber) {
-    subscribers.remove(subscriber);
-  }
 }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/webhook/DiscordWebhook.java

@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.webhook;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.config.SonarConfiguration;
+
+import javax.net.ssl.HttpsURLConnection;
+import java.io.OutputStream;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.function.Supplier;
+
+@RequiredArgsConstructor
+public final class DiscordWebhook {
+  private final String url;
+
+  private static final Gson GSON = new GsonBuilder().disableInnerClassSerialization().create();
+
+  private static final ExecutorService HTTP_REQUEST_SERVICE = Executors.newSingleThreadExecutor();
+
+  public void post(final Supplier<SonarConfiguration.Webhook.Embed> embed) {
+    HTTP_REQUEST_SERVICE.execute(() -> {
+      try {
+        final String serializedContent = prepareSerializedContent(embed.get());
+        final HttpsURLConnection urlConnection = prepareConnection(new URL(url), serializedContent);
+
+        try (final OutputStream outputStream = urlConnection.getOutputStream()) {
+          outputStream.write(serializedContent.getBytes(StandardCharsets.UTF_8));
+        }
+        // Check if the connection was a success
+        if (urlConnection.getResponseCode() != 204) {
+          throw new IllegalStateException("Unexpected response code " + urlConnection.getResponseCode());
+        }
+      } catch (Exception exception) {
+        Sonar.get().getLogger().error("Could not send webhook: {}", exception);
+      }
+    });
+  }
+
+  private String prepareSerializedContent(final SonarConfiguration.Webhook.@NotNull Embed embed) {
+    final String content = Sonar.get().getConfig().getWebhook().getContent();
+    final String username = Sonar.get().getConfig().getWebhook().getUsername();
+    final String avatarUrl = Sonar.get().getConfig().getWebhook().getAvatarUrl();
+
+    int rgb = embed.getR();
+    rgb = (rgb << 8) + embed.getG();
+    rgb = (rgb << 8) + embed.getB();
+
+    final Webhook.EmbedMessage embedMessage = new Webhook.EmbedMessage(
+      embed.getTitle(), embed.getDescription(), embed.getTitleUrl(), rgb, new Webhook.Field[0],
+      new Webhook.Footer(Sonar.get().getConfig().getWebhook().getFooter().getText(),
+        Sonar.get().getConfig().getWebhook().getFooter().getIconUrl()));
+    final List<Webhook.EmbedMessage> embeds = Collections.singletonList(embedMessage);
+
+    final Webhook webhook = new Webhook(content, username, avatarUrl, false, embeds);
+    return GSON.toJson(webhook);
+  }
+
+  private @NotNull HttpsURLConnection prepareConnection(final @NotNull URL url,
+                                                        final @NotNull String serializedContent) throws Exception {
+    final HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();
+    // Set connection timeout
+    urlConnection.setConnectTimeout(15000);
+    // Set necessary properties
+    urlConnection.setRequestProperty("Content-Type", "application/json");
+    urlConnection.setRequestProperty("Content-Length", String.valueOf(serializedContent.length()));
+    urlConnection.setRequestProperty("User-Agent", "Sonar");
+    urlConnection.setDoOutput(true);
+    urlConnection.setRequestMethod("POST");
+    return urlConnection;
+  }
+
+  @SuppressWarnings("unused")
+  @RequiredArgsConstructor
+  static final class Webhook {
+    private final String content, username, avatar_url;
+    private final boolean tts;
+    private final List<EmbedMessage> embeds;
+
+    @RequiredArgsConstructor
+    static final class EmbedMessage {
+      private final String title;
+      private final String description;
+      private final String url;
+      private final int color;
+      private final Field[] fields;
+      private final Footer footer;
+    }
+
+    @RequiredArgsConstructor
+    static final class Field {
+      private final String name;
+      private final String value;
+      private final boolean inline;
+    }
+
+    @RequiredArgsConstructor
+    static final class Footer {
+      private final String text;
+      private final String icon_url;
+    }
+  }
+}

sonar-bukkit/build.gradle.kts

@@ -12,12 +12,12 @@ bukkit {
   main = "xyz.jonesdev.sonar.bukkit.SonarBukkitPlugin"
   authors = listOf("Jones Development", "Sonar Contributors")
   website = "https://jonesdev.xyz/discord/"
-  description = "Effective Anti-bot plugin for Velocity, BungeeCord, and Bukkit (1.7-latest)"
   load = BukkitPluginDescription.PluginLoadOrder.POSTWORLD
+  softDepend = listOf("Geyser-Spigot", "floodgate", "Protocolize", "packetevents", "ProtocolLib", "ViaVersion")
 
   commands {
     register("sonar") {
-      // No permission check here
+      // No permission checks here
     }
   }
 }
@@ -32,14 +32,17 @@ dependencies {
   compileOnly(project(":common"))
 
   // MiniMessage platform support
-  implementation("net.kyori:adventure-platform-bukkit:4.3.1")
+  implementation("net.kyori:adventure-platform-bukkit:4.3.2")
 
   // We have to use 1.8 for backwards compatibility
   compileOnly("org.spigotmc:spigot-api:1.8.8-R0.1-SNAPSHOT")
 
   // Implement bStats.org for metrics
   implementation("org.bstats:bstats-bukkit:3.0.2")
+
+  // Library/dependency loading
+  implementation("com.alessiodp.libby:libby-bukkit:2.0.0-SNAPSHOT")
 }
 
-java.sourceCompatibility = JavaVersion.VERSION_1_8
-java.targetCompatibility = JavaVersion.VERSION_1_8
+java.sourceCompatibility = JavaVersion.VERSION_11
+java.targetCompatibility = JavaVersion.VERSION_11

sonar-bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/SonarBukkit.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,32 +17,48 @@
 
 package xyz.jonesdev.sonar.bukkit;
 
+import com.alessiodp.libby.BukkitLibraryManager;
 import lombok.Getter;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.platform.bukkit.BukkitAudiences;
 import org.bstats.bukkit.Metrics;
+import org.bstats.charts.SimplePie;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.SonarPlatform;
-import xyz.jonesdev.sonar.api.command.InvocationSource;
-import xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter;
 import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
-import xyz.jonesdev.sonar.api.server.ServerWrapper;
-import xyz.jonesdev.sonar.bukkit.command.BukkitInvocationSource;
 import xyz.jonesdev.sonar.bukkit.command.BukkitSonarCommand;
-import xyz.jonesdev.sonar.bukkit.verbose.ActionBarVerbose;
 import xyz.jonesdev.sonar.common.boot.SonarBootstrap;
+import xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics;
 
 import java.util.Objects;
-import java.util.Optional;
-import java.util.logging.Level;
+import java.util.UUID;
 
 @Getter
 public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
   public static SonarBukkit INSTANCE;
 
   public SonarBukkit(final @NotNull SonarBukkitPlugin plugin) {
-    super(plugin, plugin.getDataFolder(), new ActionBarVerbose(plugin.getServer()));
+    super(plugin, new BukkitLibraryManager(
+        plugin, plugin.getDataFolder().getName()),
+      plugin.getDataFolder(), SonarPlatform.BUKKIT);
     INSTANCE = this;
   }
 
+  /**
+   * Wrapper for Bukkit audiences
+   */
+  private final BukkitAudiences bukkitAudiences = BukkitAudiences.create(getPlugin());
+
+  @Override
+  public @NotNull Audience audience(final @Nullable UUID uniqueId) {
+    if (uniqueId == null) {
+      return bukkitAudiences.console();
+    }
+    return bukkitAudiences.player(uniqueId);
+  }
+
   /**
    * Create a wrapper for the plugin logger, so we can use it outside
    * the velocity module.
@@ -53,61 +69,52 @@ public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
 
     @Override
     public void info(final String message, final Object... args) {
-      getPlugin().getLogger().log(Level.INFO, message, args);
+      getPlugin().getLogger().info(buildFullMessage(message, args));
     }
 
     @Override
     public void warn(final String message, final Object... args) {
-      getPlugin().getLogger().log(Level.WARNING, message, args);
+      getPlugin().getLogger().warning(buildFullMessage(message, args));
     }
 
     @Override
     public void error(final String message, final Object... args) {
-      getPlugin().getLogger().log(Level.SEVERE, message, args);
+      getPlugin().getLogger().severe(buildFullMessage(message, args));
     }
   };
 
-  /**
-   * Create a wrapper object for our server, so we can use it outside
-   * the velocity module.
-   * <br>
-   * We have to do this, so we can access all necessary API functions.
-   */
-  public final ServerWrapper server = new ServerWrapper(SonarPlatform.BUKKIT) {
-
-    @Override
-    public Optional<InvocationSource> getOnlinePlayer(final String username) {
-      return getPlugin().getServer().getOnlinePlayers().stream()
-        .filter(player -> player.getName().equalsIgnoreCase(username))
-        .findFirst()
-        .map(BukkitInvocationSource::new);
-    }
-  };
+  private Metrics metrics;
 
   @Override
   public void enable() {
-
     // Initialize bStats.org metrics
-    new Metrics(getPlugin(), getServer().getPlatform().getMetricsId());
+    metrics = new Metrics(getPlugin(), getPlatform().getMetricsId());
+
+    // Add charts for some configuration options
+    metrics.addCustomChart(new SimplePie("verification",
+      () -> getConfig().getVerification().getTiming().getDisplayName()));
+    metrics.addCustomChart(new SimplePie("captcha",
+      () -> getConfig().getVerification().getMap().getTiming().getDisplayName()));
 
     // Register Sonar command
     Objects.requireNonNull(getPlugin().getCommand("sonar")).setExecutor(new BukkitSonarCommand());
 
-    // Register Fallback queue task
-    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(), getFallback().getQueue()::poll,
-      10L, 10L);
+    // Register traffic service
+    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
+      CachedBandwidthStatistics::reset, 20L, 20L);
 
-    // Register traffic counter reset task
-    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(), TrafficCounter::reset,
-      20L, 20L);
+    // Register queue service
+    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
+      getFallback().getQueue().getPollTask(), 10L, 10L);
 
-    // Register action bar verbose task
-    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(), getVerboseHandler()::update,
-      2L, 2L);
+    // Register verbose service
+    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
+      Sonar.get().getVerboseHandler()::update, 4L, 4L);
   }
 
   @Override
-  public void postReload() {
-    // Do nothing
+  public void disable() {
+    // Make sure to properly shutdown bStats metrics
+    metrics.shutdown();
   }
 }

sonar-bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/SonarBukkitPlugin.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/command/BukkitInvocationSource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,16 +17,17 @@
 
 package xyz.jonesdev.sonar.bukkit.command;
 
-import net.kyori.adventure.platform.bukkit.BukkitAudiences;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.command.InvocationSource;
 import xyz.jonesdev.sonar.bukkit.SonarBukkit;
 
 public final class BukkitInvocationSource extends InvocationSource {
-  private static final BukkitAudiences AUDIENCES = BukkitAudiences.create(SonarBukkit.INSTANCE.getPlugin());
-
   public BukkitInvocationSource(final @NotNull CommandSender sender) {
-    super(sender.getName(), AUDIENCES.sender(sender));
+    super(sender instanceof Player ? ((Player) sender).getUniqueId() : null,
+      SonarBukkit.INSTANCE.getBukkitAudiences().sender(sender),
+      sender instanceof Player,
+      sender::hasPermission);
   }
 }

sonar-bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/command/BukkitSonarCommand.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,128 +17,34 @@
 
 package xyz.jonesdev.sonar.bukkit.command;
 
-import net.kyori.adventure.text.Component;
-import org.bukkit.command.*;
-import org.bukkit.entity.Player;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.command.CommandInvocation;
 import xyz.jonesdev.sonar.api.command.InvocationSource;
 import xyz.jonesdev.sonar.api.command.SonarCommand;
-import xyz.jonesdev.sonar.api.command.subcommand.Subcommand;
-import xyz.jonesdev.sonar.api.command.subcommand.argument.Argument;
 
-import java.util.Arrays;
 import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
 
 import static java.util.Collections.emptyList;
 
 public final class BukkitSonarCommand implements CommandExecutor, TabExecutor, SonarCommand {
-  {
-    cacheHelpMessage();
-  }
 
   @Override
   public boolean onCommand(final CommandSender sender,
                            final Command command,
                            final String label,
                            final String[] args) {
-    if (!(sender instanceof ConsoleCommandSender)) {
-      // Check if the player actually has the permission to run the command
-      if (!sender.hasPermission("sonar.command")) {
-        sender.sendMessage(Sonar.get().getConfig().getNoPermission());
-        return false;
-      }
-      // Checking if it contains will only break more since it can throw
-      // a NullPointerException if the cache is being accessed from parallel threads
-      DELAY.cleanUp(); // Clean up the cache
-      final long mapTimestamp = DELAY.asMap().getOrDefault(sender, -1L);
-
-      // There were some exploits with spamming commands in the past.
-      // Spamming should be prevented, especially if some heavy operations are done,
-      // which is not the case here but let's still stay safe!
-      if (mapTimestamp > 0L) {
-        sender.sendMessage(Sonar.get().getConfig().getCommandCoolDown());
-
-        // Format delay
-        final long timestamp = System.currentTimeMillis();
-        final double left = 0.5D - (timestamp - mapTimestamp) / 1000D;
-
-        sender.sendMessage(
-          Sonar.get().getConfig().getCommandCoolDownLeft()
-            .replace("%time-left%", Sonar.DECIMAL_FORMAT.format(left))
-        );
-        return false;
-      }
-
-      DELAY.put(sender);
-    }
-
-    Optional<Subcommand> subcommand = Optional.empty();
-
+    // Create our own invocation source wrapper to handle messages properly
     final InvocationSource invocationSource = new BukkitInvocationSource(sender);
-
-    if (args.length > 0) {
-      // Search subcommand if command arguments are present
-      subcommand = Sonar.get().getSubcommandRegistry().getSubcommands().parallelStream()
-        .filter(sub -> sub.getInfo().name().equalsIgnoreCase(args[0])
-          || Arrays.stream(sub.getInfo().aliases())
-          .anyMatch(alias -> alias.equalsIgnoreCase(args[0])))
-        .findFirst();
-
-      // Check permissions for subcommands
-      if (subcommand.isPresent()) {
-        if (!subcommand.get().getInfo().onlyConsole()
-          && !sender.hasPermission(subcommand.get().getPermission())
-        ) {
-          invocationSource.sendMessage(Sonar.get().getConfig().getSubCommandNoPerm()
-            .replace("%permission%", subcommand.get().getPermission()));
-          return false;
-        }
-      }
-    }
-
-    subcommand.ifPresent(sub -> {
-      if (sub.getInfo().onlyPlayers() && !(sender instanceof Player)) {
-        invocationSource.sendMessage(Sonar.get().getConfig().getPlayersOnly());
-        return;
-      }
-
-      if (sub.getInfo().onlyConsole() && !(sender instanceof ConsoleCommandSender)) {
-        invocationSource.sendMessage(Sonar.get().getConfig().getConsoleOnly());
-        return;
-      }
-
-      final CommandInvocation commandInvocation = new CommandInvocation(invocationSource, sub, args);
-
-      // The subcommands has arguments which are not present in the executed command
-      if (sub.getInfo().arguments().length > 0
-        && commandInvocation.getRawArguments().length <= 1) {
-        invocationSource.sendMessage(Sonar.get().getConfig().getIncorrectCommandUsage()
-          .replace("%usage%", sub.getInfo().name() + " (" + sub.getArguments() + ")"));
-        return;
-      }
-
-      // Execute the sub command with the custom invocation properties
-      sub.execute(commandInvocation);
-    });
-
-    if (!subcommand.isPresent()) {
-
-      // Re-use the old, cached help message since we don't want to scan
-      // for each subcommand and it's arguments/attributes every time
-      // someone runs /sonar since the subcommand don't change
-      for (final Component component : CACHED_HELP_MESSAGE) {
-        invocationSource.sendMessage(component);
-      }
-    }
-    return false;
+    // Pass the invocation source and command arguments to our command handler
+    handle(invocationSource, args);
+    return true; // Valid
   }
 
   @Override
-  public List<String> onTabComplete(final CommandSender sender,
+  public List<String> onTabComplete(final @NotNull CommandSender sender,
                                     final Command command,
                                     final String commandAlias,
                                     final String @NotNull [] args) {
@@ -146,33 +52,6 @@ public final class BukkitSonarCommand implements CommandExecutor, TabExecutor, S
     if (!sender.hasPermission("sonar.command")) {
       return emptyList();
     }
-    if (args.length <= 1) {
-      if (TAB_SUGGESTIONS.isEmpty()) {
-        for (final Subcommand subcommand : Sonar.get().getSubcommandRegistry().getSubcommands()) {
-          TAB_SUGGESTIONS.add(subcommand.getInfo().name());
-
-          if (subcommand.getInfo().aliases().length > 0) {
-            TAB_SUGGESTIONS.addAll(Arrays.asList(subcommand.getInfo().aliases()));
-          }
-        }
-      }
-      return TAB_SUGGESTIONS;
-    } else if (args.length == 2) {
-      if (ARG_TAB_SUGGESTIONS.isEmpty()) {
-        for (final Subcommand subcommand : Sonar.get().getSubcommandRegistry().getSubcommands()) {
-          final List<String> parsedArguments = Arrays.stream(subcommand.getInfo().arguments())
-            .map(Argument::value)
-            .collect(Collectors.toList());
-          ARG_TAB_SUGGESTIONS.put(subcommand.getInfo().name(), parsedArguments);
-          for (final String alias : subcommand.getInfo().aliases()) {
-            ARG_TAB_SUGGESTIONS.put(alias, parsedArguments);
-          }
-        }
-      }
-
-      final String subCommandName = args[0].toLowerCase();
-      return ARG_TAB_SUGGESTIONS.getOrDefault(subCommandName, emptyList());
-    }
-    return emptyList();
+    return getCachedTabSuggestions(args);
   }
 }

sonar-bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/verbose/ActionBarVerbose.java

@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bukkit.verbose;
-
-import lombok.RequiredArgsConstructor;
-import net.md_5.bungee.api.chat.TextComponent;
-import org.bukkit.Server;
-import org.bukkit.entity.Player;
-import xyz.jonesdev.sonar.api.verbose.Verbose;
-
-@RequiredArgsConstructor
-public final class ActionBarVerbose extends Verbose {
-  private final Server server;
-
-  public void broadcast(final String message) {
-    final TextComponent component = new TextComponent(message);
-
-    synchronized (subscribers) {
-      for (final String subscriber : subscribers) {
-        final Player player = server.getPlayer(subscriber);
-        if (player != null) {
-          //player.sendMessage(ChatMessageType.ACTION_BAR, component);
-        }
-      }
-    }
-  }
-}

sonar-bungee/build.gradle.kts

@@ -9,27 +9,25 @@ bungee {
   version = rootProject.version.toString().split("-")[0]
   main = "xyz.jonesdev.sonar.bungee.SonarBungeePlugin"
   author = "Jones Development, Sonar Contributors"
-  description = "Effective Anti-bot plugin for Velocity, BungeeCord, and Bukkit (1.7-latest)"
+  softDepends = setOf("Geyser-BungeeCord", "floodgate", "Protocolize", "ViaVersion")
 }
 
 dependencies {
   compileOnly(project(":api"))
   compileOnly(project(":common"))
 
-  implementation("com.velocitypowered:velocity-native:1.1.9") {
-    exclude(group = "com.google.guava")
-    exclude(group = "io.netty")
-    exclude(group = "org.checkerframework")
-  }
-
-  compileOnly("net.md_5:bungeecord:1.20.2-rc2-SNAPSHOT")
+  compileOnly("net.md_5:bungeecord-proxy:master-SNAPSHOT")
+  testCompileOnly("net.md_5:bungeecord-proxy:master-SNAPSHOT")
 
   // MiniMessage platform support
-  implementation("net.kyori:adventure-platform-bungeecord:4.3.1")
+  implementation("net.kyori:adventure-platform-bungeecord:4.3.2")
 
   // Implement bStats.org for metrics
   implementation("org.bstats:bstats-bungeecord:3.0.2")
+
+  // Library/dependency loading
+  implementation("com.alessiodp.libby:libby-bungee:2.0.0-SNAPSHOT")
 }
 
-java.sourceCompatibility = JavaVersion.VERSION_1_8
-java.targetCompatibility = JavaVersion.VERSION_1_8
+java.sourceCompatibility = JavaVersion.VERSION_11
+java.targetCompatibility = JavaVersion.VERSION_11

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/SonarBungee.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,35 +17,48 @@
 
 package xyz.jonesdev.sonar.bungee;
 
+import com.alessiodp.libby.BungeeLibraryManager;
 import lombok.Getter;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.platform.bungeecord.BungeeAudiences;
 import org.bstats.bungeecord.Metrics;
+import org.bstats.charts.SimplePie;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.SonarPlatform;
-import xyz.jonesdev.sonar.api.command.InvocationSource;
-import xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter;
 import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
-import xyz.jonesdev.sonar.api.server.ServerWrapper;
-import xyz.jonesdev.sonar.bungee.command.BungeeInvocationSource;
 import xyz.jonesdev.sonar.bungee.command.BungeeSonarCommand;
-import xyz.jonesdev.sonar.bungee.fallback.FallbackListener;
-import xyz.jonesdev.sonar.bungee.fallback.injection.BaseInjectionHelper;
-import xyz.jonesdev.sonar.bungee.fallback.injection.ChildChannelInitializer;
-import xyz.jonesdev.sonar.bungee.verbose.VerboseWrapper;
+import xyz.jonesdev.sonar.bungee.fallback.FallbackInjectionHelper;
+import xyz.jonesdev.sonar.bungee.fallback.FallbackLoginListener;
 import xyz.jonesdev.sonar.common.boot.SonarBootstrap;
+import xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics;
 
-import java.util.Optional;
+import java.util.UUID;
 import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
 
 @Getter
 public final class SonarBungee extends SonarBootstrap<SonarBungeePlugin> {
   public static SonarBungee INSTANCE;
 
   public SonarBungee(final @NotNull SonarBungeePlugin plugin) {
-    super(plugin, plugin.getDataFolder(), new VerboseWrapper(plugin.getServer()));
+    super(plugin, new BungeeLibraryManager(plugin), plugin.getDataFolder(), SonarPlatform.BUNGEE);
     INSTANCE = this;
   }
 
+  /**
+   * Wrapper for BungeeCord audiences
+   */
+  private final BungeeAudiences bungeeAudiences = BungeeAudiences.create(getPlugin());
+
+  @Override
+  public @NotNull Audience audience(final @Nullable UUID uniqueId) {
+    if (uniqueId == null) {
+      return bungeeAudiences.console();
+    }
+    return bungeeAudiences.player(uniqueId);
+  }
+
   /**
    * Create a wrapper for the plugin logger, so we can use it outside
    * the velocity module.
@@ -56,66 +69,58 @@ public final class SonarBungee extends SonarBootstrap<SonarBungeePlugin> {
 
     @Override
     public void info(final String message, final Object... args) {
-      getPlugin().getLogger().log(Level.INFO, message, args);
+      getPlugin().getLogger().info(buildFullMessage(message, args));
     }
 
     @Override
     public void warn(final String message, final Object... args) {
-      getPlugin().getLogger().log(Level.WARNING, message, args);
+      getPlugin().getLogger().warning(buildFullMessage(message, args));
     }
 
     @Override
     public void error(final String message, final Object... args) {
-      getPlugin().getLogger().log(Level.SEVERE, message, args);
+      getPlugin().getLogger().severe(buildFullMessage(message, args));
     }
   };
 
-  /**
-   * Create a wrapper object for our server, so we can use it outside
-   * the velocity module.
-   * <br>
-   * We have to do this, so we can access all necessary API functions.
-   */
-  public final ServerWrapper server = new ServerWrapper(SonarPlatform.BUNGEE) {
-
-    @Override
-    public Optional<InvocationSource> getOnlinePlayer(final String username) {
-      return getPlugin().getServer().getPlayers().stream()
-        .filter(player -> player.getName().equalsIgnoreCase(username))
-        .findFirst()
-        .map(BungeeInvocationSource::new);
-    }
-  };
+  private Metrics metrics;
 
   @Override
   public void enable() {
-
     // Initialize bStats.org metrics
-    new Metrics(getPlugin(), getServer().getPlatform().getMetricsId());
+    metrics = new Metrics(getPlugin(), getPlatform().getMetricsId());
+
+    // Add charts for some configuration options
+    metrics.addCustomChart(new SimplePie("verification",
+      () -> getConfig().getVerification().getTiming().getDisplayName()));
+    metrics.addCustomChart(new SimplePie("captcha",
+      () -> getConfig().getVerification().getMap().getTiming().getDisplayName()));
 
     // Register Sonar command
     getPlugin().getServer().getPluginManager().registerCommand(getPlugin(), new BungeeSonarCommand());
 
     // Register Fallback listener
-    getPlugin().getServer().getPluginManager().registerListener(getPlugin(), new FallbackListener(getFallback()));
+    getPlugin().getServer().getPluginManager().registerListener(getPlugin(), new FallbackLoginListener());
 
-    // Register Fallback queue task
-    getPlugin().getServer().getScheduler().schedule(getPlugin(), getFallback().getQueue()::poll,
-      500L, 500L, TimeUnit.MILLISECONDS);
-
-    // Register traffic counter reset task
-    getPlugin().getServer().getScheduler().schedule(getPlugin(), TrafficCounter::reset,
+    // Register traffic service
+    getPlugin().getServer().getScheduler().schedule(getPlugin(), CachedBandwidthStatistics::reset,
       1L, 1L, TimeUnit.SECONDS);
 
-    // Register action bar verbose task
-    getPlugin().getServer().getScheduler().schedule(getPlugin(), getVerboseHandler()::update,
-      100L, 100L, TimeUnit.MILLISECONDS);
+    // Register queue service
+    getPlugin().getServer().getScheduler().schedule(getPlugin(), getFallback().getQueue().getPollTask(),
+      500L, 500L, TimeUnit.MILLISECONDS);
 
-    // Inject base into ProtocolUtils
-    BaseInjectionHelper.inject(ChildChannelInitializer.INSTANCE);
+    // Register verbose service
+    getPlugin().getServer().getScheduler().schedule(getPlugin(), Sonar.get().getVerboseHandler()::update,
+      200L, 200L, TimeUnit.MILLISECONDS);
+
+    // Make sure to inject into the server's connection handler
+    FallbackInjectionHelper.inject();
   }
 
   @Override
-  public void postReload() {
+  public void disable() {
+    // Make sure to properly shutdown bStats metrics
+    metrics.shutdown();
   }
 }

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/SonarBungeePlugin.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/command/BungeeInvocationSource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,16 +17,17 @@
 
 package xyz.jonesdev.sonar.bungee.command;
 
-import net.kyori.adventure.platform.bungeecord.BungeeAudiences;
 import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.command.InvocationSource;
 import xyz.jonesdev.sonar.bungee.SonarBungee;
 
 public final class BungeeInvocationSource extends InvocationSource {
-  private static final BungeeAudiences AUDIENCES = BungeeAudiences.create(SonarBungee.INSTANCE.getPlugin());
-
   public BungeeInvocationSource(final @NotNull CommandSender sender) {
-    super(sender.getName(), AUDIENCES.sender(sender));
+    super(sender instanceof ProxiedPlayer ? ((ProxiedPlayer) sender).getUniqueId() : null,
+      SonarBungee.INSTANCE.getBungeeAudiences().sender(sender),
+      sender instanceof ProxiedPlayer,
+      sender::hasPermission);
   }
 }

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/command/BungeeSonarCommand.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,161 +17,34 @@
 
 package xyz.jonesdev.sonar.bungee.command;
 
-import net.kyori.adventure.text.Component;
 import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.plugin.Command;
 import net.md_5.bungee.api.plugin.TabExecutor;
-import net.md_5.bungee.command.ConsoleCommandSender;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.command.CommandInvocation;
 import xyz.jonesdev.sonar.api.command.InvocationSource;
 import xyz.jonesdev.sonar.api.command.SonarCommand;
-import xyz.jonesdev.sonar.api.command.subcommand.Subcommand;
-import xyz.jonesdev.sonar.api.command.subcommand.argument.Argument;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
 
 import static java.util.Collections.emptyList;
 
 public final class BungeeSonarCommand extends Command implements TabExecutor, SonarCommand {
   public BungeeSonarCommand() {
     super("sonar");
-    cacheHelpMessage();
   }
 
   @Override
-  @SuppressWarnings({"redundantSuppression"})
   public void execute(final @NotNull CommandSender sender, final String[] args) {
-    if (!(sender instanceof ConsoleCommandSender)) {
-      // Check if the player actually has the permission to run the command
-      if (!sender.hasPermission("sonar.command")) {
-        sender.sendMessage(new TextComponent(Sonar.get().getConfig().getNoPermission()));
-        return;
-      }
-      // Checking if it contains will only break more since it can throw
-      // a NullPointerException if the cache is being accessed from parallel threads
-      DELAY.cleanUp(); // Clean up the cache
-      final long mapTimestamp = DELAY.asMap().getOrDefault(sender, -1L);
-
-      // There were some exploits with spamming commands in the past.
-      // Spamming should be prevented, especially if some heavy operations are done,
-      // which is not the case here but let's still stay safe!
-      if (mapTimestamp > 0L) {
-        sender.sendMessage(new TextComponent(Sonar.get().getConfig().getCommandCoolDown()));
-
-        // Format delay
-        final long timestamp = System.currentTimeMillis();
-        final double left = 0.5D - (timestamp - mapTimestamp) / 1000D;
-
-        sender.sendMessage(new TextComponent(Sonar.get().getConfig().getCommandCoolDownLeft()
-          .replace("%time-left%", Sonar.DECIMAL_FORMAT.format(left))));
-        return;
-      }
-
-      DELAY.put(sender);
-    }
-
-    Optional<Subcommand> subcommand = Optional.empty();
-
+    // Create our own invocation source wrapper to handle messages properly
     final InvocationSource invocationSource = new BungeeInvocationSource(sender);
-
-    if (args.length > 0) {
-      // Search subcommand if command arguments are present
-      subcommand = Sonar.get().getSubcommandRegistry().getSubcommands().parallelStream()
-        .filter(sub -> sub.getInfo().name().equalsIgnoreCase(args[0])
-          || Arrays.stream(sub.getInfo().aliases())
-          .anyMatch(alias -> alias.equalsIgnoreCase(args[0])))
-        .findFirst();
-
-      // Check permissions for subcommands
-      if (subcommand.isPresent()) {
-        if (!subcommand.get().getInfo().onlyConsole()
-          && !sender.hasPermission(subcommand.get().getPermission())
-        ) {
-          invocationSource.sendMessage(
-            Sonar.get().getConfig().getSubCommandNoPerm()
-              .replace("%permission%", subcommand.get().getPermission())
-          );
-          return;
-        }
-      }
-    }
-
-    subcommand.ifPresent(sub -> {
-      if (sub.getInfo().onlyPlayers() && !(sender instanceof ProxiedPlayer)) {
-        invocationSource.sendMessage(Sonar.get().getConfig().getPlayersOnly());
-        return;
-      }
-
-      if (sub.getInfo().onlyConsole() && !(sender instanceof ConsoleCommandSender)) {
-        invocationSource.sendMessage(Sonar.get().getConfig().getConsoleOnly());
-        return;
-      }
-
-      final CommandInvocation commandInvocation = new CommandInvocation(invocationSource, sub, args);
-
-      // The subcommands has arguments which are not present in the executed command
-      if (sub.getInfo().arguments().length > 0
-        && commandInvocation.getRawArguments().length <= 1) {
-        invocationSource.sendMessage(Sonar.get().getConfig().getIncorrectCommandUsage()
-          .replace("%usage%", sub.getInfo().name() + " (" + sub.getArguments() + ")"));
-        return;
-      }
-
-      // Execute the sub command with the custom invocation properties
-      sub.execute(commandInvocation);
-    });
-
-    if (!subcommand.isPresent()) {
-
-      // Re-use the old, cached help message since we don't want to scan
-      // for each subcommand and it's arguments/attributes every time
-      // someone runs /sonar since the subcommand don't change
-      for (final Component component : CACHED_HELP_MESSAGE) {
-        invocationSource.sendMessage(component);
-      }
-    }
+    // Pass the invocation source and command arguments to our command handler
+    handle(invocationSource, args);
   }
 
   @Override
-  public Iterable<String> onTabComplete(final CommandSender sender, final String @NotNull [] args) {
+  public Iterable<String> onTabComplete(final @NotNull CommandSender sender, final String @NotNull [] args) {
     // Do not allow tab completion if the player does not have the required permission
     if (!sender.hasPermission("sonar.command")) {
       return emptyList();
     }
-    if (args.length <= 1) {
-      if (TAB_SUGGESTIONS.isEmpty()) {
-        for (final Subcommand subcommand : Sonar.get().getSubcommandRegistry().getSubcommands()) {
-          TAB_SUGGESTIONS.add(subcommand.getInfo().name());
-
-          if (subcommand.getInfo().aliases().length > 0) {
-            TAB_SUGGESTIONS.addAll(Arrays.asList(subcommand.getInfo().aliases()));
-          }
-        }
-      }
-      return TAB_SUGGESTIONS;
-    } else if (args.length == 2) {
-      if (ARG_TAB_SUGGESTIONS.isEmpty()) {
-        for (final Subcommand subcommand : Sonar.get().getSubcommandRegistry().getSubcommands()) {
-          final List<String> parsedArguments = Arrays.stream(subcommand.getInfo().arguments())
-            .map(Argument::value)
-            .collect(Collectors.toList());
-          ARG_TAB_SUGGESTIONS.put(subcommand.getInfo().name(), parsedArguments);
-          for (final String alias : subcommand.getInfo().aliases()) {
-            ARG_TAB_SUGGESTIONS.put(alias, parsedArguments);
-          }
-        }
-      }
-
-      final String subCommandName = args[0].toLowerCase();
-      return ARG_TAB_SUGGESTIONS.getOrDefault(subCommandName, emptyList());
-    }
-    return emptyList();
+    return getCachedTabSuggestions(args);
   }
 }

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/FallbackChannelHandler.java

@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.bungee.fallback;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.CorruptedFrameException;
+import net.md_5.bungee.netty.ChannelWrapper;
+import net.md_5.bungee.netty.HandlerBoss;
+import net.md_5.bungee.protocol.DefinedPacket;
+import net.md_5.bungee.protocol.PacketWrapper;
+import net.md_5.bungee.protocol.packet.Handshake;
+import net.md_5.bungee.protocol.packet.LoginRequest;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.ReflectiveOperationException;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.fallback.FallbackUser;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.common.fallback.FallbackBandwidthHandler;
+import xyz.jonesdev.sonar.common.fallback.FallbackChannelHandlerAdapter;
+import xyz.jonesdev.sonar.common.fallback.FallbackUserWrapper;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
+import xyz.jonesdev.sonar.common.utility.geyser.GeyserUtil;
+
+import java.lang.reflect.Field;
+import java.net.InetSocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.UUID;
+
+import static net.md_5.bungee.netty.PipelineUtils.*;
+import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_BANDWIDTH;
+import static xyz.jonesdev.sonar.common.fallback.FallbackUserWrapper.customDisconnect;
+import static xyz.jonesdev.sonar.common.fallback.FallbackUserWrapper.deject;
+import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer.*;
+
+public final class FallbackChannelHandler extends FallbackChannelHandlerAdapter {
+
+  public FallbackChannelHandler(final @NotNull Channel channel) {
+    super(channel);
+  }
+
+  private static final Field CHANNEL_WRAPPER_FIELD;
+
+  static {
+    try {
+      CHANNEL_WRAPPER_FIELD = HandlerBoss.class.getDeclaredField("channel");
+      CHANNEL_WRAPPER_FIELD.setAccessible(true);
+    } catch (Exception exception) {
+      throw new ReflectiveOperationException(exception);
+    }
+  }
+
+  @Override
+  public void channelRead(final @NotNull ChannelHandlerContext ctx, final Object msg) throws Exception {
+    // Intercept any packets processed by BungeeCord
+    if (msg instanceof PacketWrapper) {
+      final PacketWrapper packetWrapper = (PacketWrapper) msg;
+      final DefinedPacket wrappedPacket = packetWrapper.packet;
+      // Don't handle any invalid packets
+      if (wrappedPacket != null) {
+        // Intercept any handshake packet by the client
+        if (wrappedPacket instanceof Handshake) {
+          handleHandshake((Handshake) wrappedPacket);
+        }
+        // Intercept any server login packet by the client
+        if (wrappedPacket instanceof LoginRequest) {
+          handleLogin(ctx, (LoginRequest) wrappedPacket, msg);
+          return;
+        }
+      }
+    }
+    // Make sure to let the server handle the rest
+    ctx.fireChannelRead(msg);
+  }
+
+  private void handleHandshake(final @NotNull Handshake handshake) throws Exception {
+    // Check if the player has already sent a handshake packet
+    if (protocolVersion != null) {
+      throw new CorruptedFrameException("Already sent handshake");
+    }
+    // Check if the hostname is invalid
+    if (handshake.getHost().isEmpty()) {
+      throw new CorruptedFrameException("Hostname is empty");
+    }
+    // Store the protocol version
+    protocolVersion = ProtocolVersion.fromId(handshake.getProtocolVersion());
+    // Connections from unknown protocol versions will be discarded
+    // as this is the safest way of handling unwanted connections
+    if (protocolVersion.isUnknown()) {
+      // Sonar does NOT support snapshots or unknown versions;
+      // I'll try my best to stay up-to-date!
+      throw new CorruptedFrameException("Unknown protocol");
+    }
+    // Hook the traffic listener
+    // TODO: Can we implement this in channelActive?
+    channel.pipeline().addFirst(FALLBACK_BANDWIDTH, FallbackBandwidthHandler.INSTANCE);
+  }
+
+  private void handleLogin(final @NotNull ChannelHandlerContext ctx,
+                           final @NotNull LoginRequest loginRequest,
+                           final @NotNull Object wrappedMessage) throws Exception {
+    // Check if the player has already sent a login packet
+    if (username != null) {
+      throw new CorruptedFrameException("Already logged on");
+    }
+    // Increase joins per second for the action bar verbose
+    GlobalSonarStatistics.countLogin();
+    // Store the username
+    username = loginRequest.getData();
+    // Make sure to use the potentially modified, real IP
+    final HandlerBoss handlerBoss = channel.pipeline().get(HandlerBoss.class);
+    final ChannelWrapper channelWrapper = (ChannelWrapper) CHANNEL_WRAPPER_FIELD.get(handlerBoss);
+    final InetSocketAddress socketAddress = (InetSocketAddress) channelWrapper.getRemoteAddress();
+    inetAddress = socketAddress.getAddress();
+
+    // Check the blacklist here since we cannot let the player "ghost join"
+    if (FALLBACK.getBlacklist().asMap().containsKey(inetAddress)) {
+      customDisconnect(channel, protocolVersion, blacklisted, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Don't continue the verification process if the verification is disabled
+    if (!Sonar.get().getFallback().shouldVerifyNewPlayers()) {
+      ctx.fireChannelRead(wrappedMessage);
+      deject(channel.pipeline());
+      return;
+    }
+
+    // Completely skip Geyser connections
+    if (GeyserUtil.isGeyserConnection(channel, socketAddress)) {
+      ctx.fireChannelRead(wrappedMessage);
+      deject(channel.pipeline());
+      return;
+    }
+
+    // Check if the player is already queued since we don't want bots to flood the queue
+    if (FALLBACK.getQueue().getQueuedPlayers().containsKey(inetAddress)) {
+      customDisconnect(channel, protocolVersion, alreadyQueued, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Check if Fallback is already verifying a player
+    // → is another player with the same IP address connected to Fallback?
+    if (FALLBACK.getConnected().containsKey(loginRequest.getData())
+      || FALLBACK.getConnected().containsValue(inetAddress)) {
+      customDisconnect(channel, protocolVersion, alreadyVerifying, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Check if the protocol ID of the player is not allowed to enter the server
+    if (Sonar.get().getConfig().getVerification().getBlacklistedProtocols()
+      .contains(protocolVersion.getProtocol())) {
+      customDisconnect(channel, protocolVersion, protocolBlacklisted, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Make sure we actually have to verify the player
+    final String offlineUUIDString = "OfflinePlayer:" + loginRequest.getData();
+    final UUID offlineUUID = UUID.nameUUIDFromBytes(offlineUUIDString.getBytes(StandardCharsets.UTF_8));
+    if (Sonar.get().getVerifiedPlayerController().has(inetAddress, offlineUUID)) {
+      ctx.fireChannelRead(wrappedMessage);
+      deject(channel.pipeline());
+      return;
+    }
+
+    // Check if the IP address is currently being rate-limited
+    if (!FALLBACK.getRatelimiter().attempt(inetAddress)) {
+      customDisconnect(channel, protocolVersion, reconnectedTooFast, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Check if the protocol ID of the player is allowed to bypass verification
+    if (Sonar.get().getConfig().getVerification().getWhitelistedProtocols()
+      .contains(protocolVersion.getProtocol())) {
+      ctx.fireChannelRead(wrappedMessage);
+      deject(channel.pipeline());
+      return;
+    }
+
+    // Queue the connection for further processing
+    FALLBACK.getQueue().queue(inetAddress, () -> channel.eventLoop().execute(() -> {
+      // Check if the username matches the valid name regex to prevent
+      // UTF-16 names or other types of exploits
+      if (!Sonar.get().getConfig().getVerification().getValidNameRegex()
+        .matcher(loginRequest.getData()).matches()) {
+        customDisconnect(channel, protocolVersion, invalidUsername, PACKET_ENCODER, BOSS_HANDLER);
+        return;
+      }
+
+      // Create an instance for the Fallback connection
+      final FallbackUser user = new FallbackUserWrapper(channel, inetAddress, protocolVersion);
+      // Let the verification handler take over the channel
+      user.hijack(loginRequest.getData(), offlineUUID, PACKET_ENCODER, PACKET_DECODER, TIMEOUT_HANDLER, BOSS_HANDLER);
+    }));
+  }
+}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/FallbackChannelInitializer.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.bungee.fallback;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelInitializer;
+import lombok.RequiredArgsConstructor;
+import xyz.jonesdev.sonar.api.ReflectiveOperationException;
+
+import java.lang.reflect.Method;
+
+import static net.md_5.bungee.netty.PipelineUtils.PACKET_DECODER;
+import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_HANDLER;
+
+@RequiredArgsConstructor
+public final class FallbackChannelInitializer extends ChannelInitializer<Channel> {
+  private static final Method INIT_CHANNEL_METHOD;
+
+  static {
+    try {
+      INIT_CHANNEL_METHOD = ChannelInitializer.class.getDeclaredMethod("initChannel", Channel.class);
+      INIT_CHANNEL_METHOD.setAccessible(true);
+    } catch (Throwable throwable) {
+      throw new ReflectiveOperationException(throwable);
+    }
+  }
+
+  private final ChannelInitializer<Channel> originalChannelInitializer;
+
+  @Override
+  protected void initChannel(final Channel channel) throws Exception {
+    // Invoke the original method
+    try {
+      INIT_CHANNEL_METHOD.invoke(originalChannelInitializer, channel);
+    } catch (Throwable throwable) {
+      throw new ReflectiveOperationException(throwable);
+    }
+
+    if (channel.pipeline().get(PACKET_DECODER) != null) {
+      channel.pipeline().addAfter(PACKET_DECODER, FALLBACK_HANDLER, new FallbackChannelHandler(channel));
+    }
+  }
+}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/FallbackInjectionHelper.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.bungee.fallback.injection;
+package xyz.jonesdev.sonar.bungee.fallback;
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelInitializer;
@@ -27,20 +27,27 @@ import xyz.jonesdev.sonar.api.ReflectiveOperationException;
 import java.lang.reflect.Field;
 
 @UtilityClass
-public class BaseInjectionHelper {
-  public void inject(final ChannelInitializer<Channel> childHandler) {
+public class FallbackInjectionHelper {
+  public void inject() {
     try {
       final Field childField = PipelineUtils.class.getField("SERVER_CHILD");
       childField.setAccessible(true);
 
+      // Make sure to store the original channel initializer
+      final ChannelInitializer<Channel> originalInitializer = PipelineUtils.SERVER_CHILD;
+      final ChannelInitializer<Channel> fallbackInitializer = new FallbackChannelInitializer(originalInitializer);
+
       final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
       unsafeField.setAccessible(true);
       final Unsafe unsafe = (Unsafe) unsafeField.get(null);
 
+      // Get the base object (the object containing the field)
       final Object base = unsafe.staticFieldBase(childField);
+      // Get the offset of the static field within its class
       final long offset = unsafe.staticFieldOffset(childField);
 
-      unsafe.putObject(base, offset, childHandler);
+      // Replace the original channel initializer
+      unsafe.putObject(base, offset, fallbackInitializer);
     } catch (Exception exception) {
       throw new ReflectiveOperationException(exception);
     }

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/FallbackListener.java

@@ -1,129 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback;
-
-import com.velocitypowered.natives.compression.VelocityCompressor;
-import com.velocitypowered.natives.util.Natives;
-import io.netty.channel.ChannelPipeline;
-import lombok.RequiredArgsConstructor;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.serializer.json.JSONComponentSerializer;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.connection.PendingConnection;
-import net.md_5.bungee.api.event.PostLoginEvent;
-import net.md_5.bungee.api.plugin.Listener;
-import net.md_5.bungee.compress.PacketCompressor;
-import net.md_5.bungee.compress.PacketDecompressor;
-import net.md_5.bungee.connection.InitialHandler;
-import net.md_5.bungee.event.EventHandler;
-import net.md_5.bungee.netty.ChannelWrapper;
-import net.md_5.bungee.protocol.packet.Kick;
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.ReflectiveOperationException;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.fallback.Fallback;
-import xyz.jonesdev.sonar.bungee.fallback.compress.FallbackPacketCompressor;
-import xyz.jonesdev.sonar.bungee.fallback.compress.FallbackPacketDecompressor;
-import xyz.jonesdev.sonar.bungee.fallback.handler.FallbackInitialHandler;
-
-import java.lang.reflect.Field;
-
-import static net.md_5.bungee.netty.PipelineUtils.FRAME_PREPENDER;
-
-@RequiredArgsConstructor
-public final class FallbackListener implements Listener {
-  private final Fallback fallback;
-
-  private static final Field CHANNEL_WRAPPER;
-
-  static {
-    try {
-      CHANNEL_WRAPPER = InitialHandler.class.getDeclaredField("ch");
-      CHANNEL_WRAPPER.setAccessible(true);
-    } catch (Throwable throwable) {
-      throw new ReflectiveOperationException(throwable);
-    }
-  }
-
-  @EventHandler
-  @SuppressWarnings("deprecation")
-  public void handle(final @NotNull PostLoginEvent event) throws Throwable {
-    if (Sonar.get().getConfig().isLockdownEnabled()) {
-      if (!event.getPlayer().hasPermission("sonar.lockdown")) {
-        final PendingConnection pendingConnection = event.getPlayer().getPendingConnection();
-        // Try to close the channel with a custom serialized disconnect component
-        if (pendingConnection instanceof FallbackInitialHandler) {
-          final FallbackInitialHandler fallbackInitialHandler = (FallbackInitialHandler) pendingConnection;
-          final Component component = Sonar.get().getConfig().getLockdownDisconnect();
-          final String serialized = JSONComponentSerializer.json().serialize(component);
-          fallbackInitialHandler.closeWith(new Kick(serialized));
-        } else {
-          // Fallback by disconnecting without a message
-          pendingConnection.disconnect();
-          Sonar.get().getLogger().warn("Fallback handler of {} is missing", event.getPlayer().getName());
-        }
-
-        if (Sonar.get().getConfig().isLockdownLogAttempts()) {
-          Sonar.get().getLogger().info(Sonar.get().getConfig().getLockdownConsoleLog()
-            .replace("%player%", event.getPlayer().getName())
-            .replace("%ip%", Sonar.get().getConfig()
-              .formatAddress(event.getPlayer().getAddress().getAddress()))
-            .replace("%protocol%",
-              String.valueOf(event.getPlayer().getPendingConnection().getVersion())));
-        }
-        return;
-      } else if (Sonar.get().getConfig().isLockdownEnableNotify()) {
-        event.getPlayer().sendMessage(new TextComponent(Sonar.get().getConfig().getLockdownNotification()));
-      }
-    }
-
-    final InitialHandler initialHandler = (InitialHandler) event.getPlayer().getPendingConnection();
-    final ChannelWrapper channelWrapper = (ChannelWrapper) CHANNEL_WRAPPER.get(initialHandler);
-
-    final ChannelPipeline pipeline = channelWrapper.getHandle().pipeline();
-
-    // You don't need the frame decoder anymore
-    if (pipeline.get(FRAME_PREPENDER) != null) {
-      pipeline.remove(FRAME_PREPENDER);
-    }
-
-    final int compressionThreshold = BungeeCord.getInstance().getConfig().getCompressionThreshold();
-
-    // Replace compression handlers
-    if (compressionThreshold > 0
-      && pipeline.get(PacketCompressor.class) != null
-      && pipeline.get(PacketDecompressor.class) != null) {
-      final VelocityCompressor compressor = Natives.compress.get().create(-1);
-
-      // Replace (de)compressor with Velocity's to ensure better performance
-      pipeline.replace(
-        PacketCompressor.class,
-        "compress",
-        // Create a new compressor instance with the Velocity compressor
-        new FallbackPacketCompressor(compressionThreshold, compressor)
-      );
-      pipeline.replace(
-        PacketDecompressor.class,
-        "decompress",
-        // Create a new decompressor instance with the Velocity decompressor
-        new FallbackPacketDecompressor(compressionThreshold, compressor)
-      );
-    }
-  }
-}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/FallbackLoginListener.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.bungee.fallback;
+
+import lombok.RequiredArgsConstructor;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
+import net.md_5.bungee.api.connection.PendingConnection;
+import net.md_5.bungee.api.event.PreLoginEvent;
+import net.md_5.bungee.api.plugin.Listener;
+import net.md_5.bungee.chat.ComponentSerializer;
+import net.md_5.bungee.connection.InitialHandler;
+import net.md_5.bungee.event.EventHandler;
+import net.md_5.bungee.event.EventPriority;
+import net.md_5.bungee.netty.ChannelWrapper;
+import net.md_5.bungee.protocol.packet.Kick;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.ReflectiveOperationException;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.bungee.SonarBungee;
+
+import java.lang.reflect.Field;
+import java.net.InetAddress;
+import java.util.Objects;
+
+import static xyz.jonesdev.sonar.common.fallback.FallbackUserWrapper.closeWith;
+
+@RequiredArgsConstructor
+public final class FallbackLoginListener implements Listener {
+
+  private static final Field CHANNEL_FIELD;
+
+  static {
+    try {
+      CHANNEL_FIELD = InitialHandler.class.getDeclaredField("ch");
+      CHANNEL_FIELD.setAccessible(true);
+    } catch (NoSuchFieldException exception) {
+      throw new ReflectiveOperationException(exception);
+    }
+  }
+
+  @SuppressWarnings("deprecation")
+  @EventHandler(priority = EventPriority.LOWEST)
+  public void handle(final @NotNull PreLoginEvent event) throws IllegalAccessException {
+    // Check if the number of online players using the same IP address as
+    // the connecting player is greater than the configured amount
+    final int maxOnlinePerIp = Sonar.get().getConfig().getMaxOnlinePerIp();
+    // Don't do anything if the setting is disabled
+    if (maxOnlinePerIp <= 0) return;
+
+    final InetAddress inetAddress = event.getConnection().getAddress().getAddress();
+
+    final long onlinePerIp = SonarBungee.INSTANCE.getPlugin().getServer().getPlayers().stream()
+      .filter(player -> Objects.equals(player.getAddress().getAddress(), inetAddress))
+      .count()
+      + 1 /* add 1 because the player hasn't been added to the list of online players yet */;
+
+    // We use '>=' because the player connecting to the server hasn't joined yet
+    if (onlinePerIp >= maxOnlinePerIp) {
+      final Component component = Sonar.get().getConfig().getTooManyOnlinePerIp();
+      final String serialized = GsonComponentSerializer.gson().serialize(component);
+      final PendingConnection connection = event.getConnection();
+      closeWith(((ChannelWrapper) CHANNEL_FIELD.get(connection)).getHandle(),
+        ProtocolVersion.fromId(connection.getVersion()),
+        new Kick(ComponentSerializer.deserialize(serialized)));
+    }
+  }
+}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/FallbackUserWrapper.java

@@ -1,60 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback;
-
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelPipeline;
-import io.netty.util.ReferenceCountUtil;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import net.kyori.adventure.text.Component;
-import net.md_5.bungee.netty.ChannelWrapper;
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.fallback.Fallback;
-import xyz.jonesdev.sonar.api.fallback.FallbackUser;
-import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
-import xyz.jonesdev.sonar.bungee.fallback.handler.FallbackInitialHandler;
-import xyz.jonesdev.sonar.common.fallback.protocol.packets.Disconnect;
-
-import java.net.InetAddress;
-
-@Getter
-@RequiredArgsConstructor
-public final class FallbackUserWrapper implements FallbackUser<ChannelWrapper, FallbackInitialHandler> {
-  private final Fallback fallback;
-  private final ChannelWrapper player;
-  private final FallbackInitialHandler connection;
-  private final Channel channel;
-  private final ChannelPipeline pipeline;
-  private final InetAddress inetAddress;
-  private final ProtocolVersion protocolVersion;
-
-  @Override
-  public void disconnect(final @NotNull Component reason) {
-    connection.closeWith(Disconnect.create(reason));
-  }
-
-  @Override
-  public void write(final @NotNull Object packet) {
-    if (channel.isActive()) {
-      channel.writeAndFlush(packet, channel.voidPromise());
-    } else {
-      ReferenceCountUtil.release(packet);
-    }
-  }
-}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/compress/FallbackPacketCompressor.java

@@ -1,115 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback.compress;
-
-import com.velocitypowered.natives.compression.VelocityCompressor;
-import io.netty.buffer.ByteBuf;
-import io.netty.channel.ChannelHandlerContext;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import net.md_5.bungee.compress.PacketCompressor;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.zip.DataFormatException;
-
-import static com.velocitypowered.natives.util.MoreByteBufUtils.ensureCompatible;
-import static com.velocitypowered.natives.util.MoreByteBufUtils.preferredBuffer;
-import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.*;
-
-@Getter
-@AllArgsConstructor
-public final class FallbackPacketCompressor extends PacketCompressor {
-  private int compressionThreshold;
-  private final @NotNull VelocityCompressor compressor;
-
-  private static final int MAX_COMPRESSED_LENGTH = 1 << 21;
-
-  @Override
-  public void setThreshold(final int compressionThreshold) {
-    this.compressionThreshold = compressionThreshold;
-  }
-
-  @Override
-  public void handlerAdded(final ChannelHandlerContext ctx) throws Exception {
-    // Do nothing
-  }
-
-  @Override
-  public void handlerRemoved(final ChannelHandlerContext ctx) throws Exception {
-    compressor.close();
-  }
-
-  @Override
-  protected void encode(final ChannelHandlerContext ctx,
-                        final @NotNull ByteBuf msg,
-                        final ByteBuf out) throws Exception {
-    final int uncompressed = msg.readableBytes();
-    if (uncompressed < compressionThreshold) {
-      // Under the threshold, do nothing.
-      writeVarInt(out, uncompressed + 1);
-      writeVarInt(out, 0);
-      out.writeBytes(msg);
-    } else {
-      handleCompressed(ctx, msg, out);
-    }
-  }
-
-  private void handleCompressed(final @NotNull ChannelHandlerContext ctx,
-                                final @NotNull ByteBuf msg,
-                                final ByteBuf out) throws DataFormatException {
-    final int uncompressed = msg.readableBytes();
-
-    write21BitVarInt(out, 0); // Fake packet length
-    writeVarInt(out, uncompressed);
-
-    final ByteBuf compatibleIn = ensureCompatible(ctx.alloc(), compressor, msg);
-
-    final int startCompressed = out.writerIndex();
-    try {
-      compressor.deflate(compatibleIn, out);
-    } finally {
-      compatibleIn.release();
-    }
-
-    final int compressedLength = out.writerIndex() - startCompressed;
-    if (compressedLength >= MAX_COMPRESSED_LENGTH) {
-      throw new DataFormatException("The server sent a very large (over 2MiB compressed) packet.");
-    }
-
-    int writerIndex = out.writerIndex();
-    int packetLength = out.readableBytes() - 3;
-    out.writerIndex(0);
-    write21BitVarInt(out, packetLength); // Rewrite packet length
-    out.writerIndex(writerIndex);
-  }
-
-  @Override
-  protected ByteBuf allocateBuffer(final ChannelHandlerContext ctx,
-                                   final @NotNull ByteBuf msg,
-                                   final boolean preferDirect) throws Exception {
-    int uncompressed = msg.readableBytes();
-    if (uncompressed < compressionThreshold) {
-      int finalBufferSize = uncompressed + 1;
-      finalBufferSize += varIntBytes(finalBufferSize);
-      return ctx.alloc().directBuffer(finalBufferSize);
-    }
-
-    final int initialBufferSize = (uncompressed - 1) + 3 + varIntBytes(uncompressed);
-    return preferredBuffer(ctx.alloc(), compressor, initialBufferSize);
-  }
-}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/compress/FallbackPacketDecompressor.java

@@ -1,98 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback.compress;
-
-import com.velocitypowered.natives.compression.VelocityCompressor;
-import io.netty.buffer.ByteBuf;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.handler.codec.CorruptedFrameException;
-import lombok.Getter;
-import net.md_5.bungee.compress.PacketDecompressor;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.List;
-
-import static com.velocitypowered.natives.util.MoreByteBufUtils.ensureCompatible;
-import static com.velocitypowered.natives.util.MoreByteBufUtils.preferredBuffer;
-import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.readVarInt;
-
-@Getter
-public final class FallbackPacketDecompressor extends PacketDecompressor {
-  private final int compressionThreshold;
-  private final @NotNull VelocityCompressor compressor;
-
-  private static final int VANILLA_MAXIMUM_UNCOMPRESSED_SIZE = 8 * 1024 * 1024; // 8MiB
-  private static final int HARD_MAXIMUM_UNCOMPRESSED_SIZE = 16 * 1024 * 1024; // 16MiB
-  private static final int UNCOMPRESSED_CAP = Boolean.getBoolean("sonar.increased-compression-cap")
-    ? HARD_MAXIMUM_UNCOMPRESSED_SIZE : VANILLA_MAXIMUM_UNCOMPRESSED_SIZE;
-
-  public FallbackPacketDecompressor(final int compressionThreshold,
-                                    final @NotNull VelocityCompressor compressor) {
-    super(); // super(compressionThreshold);
-    this.compressionThreshold = compressionThreshold;
-    this.compressor = compressor;
-  }
-
-  @Override
-  public void handlerAdded(final ChannelHandlerContext ctx) throws Exception {
-    // Do nothing
-  }
-
-  @Override
-  public void handlerRemoved(final ChannelHandlerContext ctx) throws Exception {
-    compressor.close();
-  }
-
-  @Override
-  protected void decode(final ChannelHandlerContext ctx,
-                        final @NotNull ByteBuf in,
-                        final List<Object> out) throws Exception {
-    final int claimedUncompressedSize = readVarInt(in);
-    if (claimedUncompressedSize == 0) {
-      // This message is not compressed.
-      out.add(in.retain());
-
-      // Check for invalid packet size after the packet is retained
-      final int size = in.readableBytes();
-      if (size > compressionThreshold + 2) {
-        throw new CorruptedFrameException("Invalid uncompressed packet size " + size);
-      }
-      return;
-    }
-
-    if (claimedUncompressedSize < compressionThreshold) {
-      throw new CorruptedFrameException(claimedUncompressedSize + " is less than " + compressionThreshold);
-    }
-    if (claimedUncompressedSize > UNCOMPRESSED_CAP) {
-      throw new CorruptedFrameException(claimedUncompressedSize + " exceeds maximum size");
-    }
-
-    final ByteBuf compatibleIn = ensureCompatible(ctx.alloc(), compressor, in);
-    final ByteBuf uncompressed = preferredBuffer(ctx.alloc(), compressor, claimedUncompressedSize);
-
-    try {
-      compressor.inflate(compatibleIn, uncompressed, claimedUncompressedSize);
-      out.add(uncompressed);
-    } catch (Exception exception) {
-      uncompressed.release();
-      throw exception;
-    } finally {
-      compatibleIn.release();
-    }
-  }
-}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/handler/FallbackInitialHandler.java

@@ -1,91 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback.handler;
-
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelFutureListener;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.config.ListenerInfo;
-import net.md_5.bungee.connection.InitialHandler;
-import net.md_5.bungee.netty.ChannelWrapper;
-import net.md_5.bungee.protocol.packet.LoginRequest;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.fallback.Fallback;
-import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
-import xyz.jonesdev.sonar.bungee.fallback.FallbackUserWrapper;
-
-import java.net.InetAddress;
-import java.util.Objects;
-import java.util.concurrent.TimeUnit;
-
-public final class FallbackInitialHandler extends InitialHandler {
-  public FallbackInitialHandler(final BungeeCord bungee, final ListenerInfo listener) {
-    super(bungee, listener);
-  }
-
-  private static final @NotNull Fallback FALLBACK = Objects.requireNonNull(Sonar.get().getFallback());
-  private ChannelWrapper channelWrapper;
-  @SuppressWarnings("unused") // TODO: remove later
-  private @Nullable FallbackUserWrapper player;
-
-  @Override
-  public void connected(final ChannelWrapper channelWrapper) throws Exception {
-    this.channelWrapper = channelWrapper;
-    super.connected(channelWrapper);
-  }
-
-  @Override
-  public void handle(final LoginRequest loginRequest) throws Exception {
-    final InetAddress inetAddress = getAddress().getAddress();
-
-    if (player == null && !Sonar.get().getVerifiedPlayerController().has(inetAddress)) {
-      final Channel channel = channelWrapper.getHandle();
-
-      player = new FallbackUserWrapper(
-        FALLBACK, channelWrapper, this,
-        channel, channel.pipeline(), inetAddress,
-        ProtocolVersion.fromId(getHandshake().getProtocolVersion())
-      );
-      // TODO: implement Fallback
-    }
-
-    super.handle(loginRequest);
-  }
-
-  // Mostly taken from Velocity
-  public void closeWith(final Object msg) {
-    if (player != null && player.getChannel().isActive()) {
-      boolean is17 = player.getProtocolVersion().compareTo(ProtocolVersion.MINECRAFT_1_8) < 0
-        && player.getProtocolVersion().compareTo(ProtocolVersion.MINECRAFT_1_7_2) >= 0;
-      if (is17) {
-        player.getChannel().eventLoop().execute(() -> {
-          channelWrapper.getHandle().config().setAutoRead(false);
-          player.getChannel().eventLoop().schedule(() -> {
-            channelWrapper.markClosed();
-            player.getChannel().writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
-          }, 250L, TimeUnit.MILLISECONDS);
-        });
-      } else {
-        channelWrapper.markClosed();
-        player.getChannel().writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
-      }
-    }
-  }
-}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/injection/BaseChannelInitializer.java

@@ -1,82 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback.injection;
-
-import io.netty.buffer.PooledByteBufAllocator;
-import io.netty.channel.*;
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.netty.HandlerBoss;
-import net.md_5.bungee.netty.PipelineUtils;
-import net.md_5.bungee.protocol.Varint21LengthFieldPrepender;
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.ReflectiveOperationException;
-import xyz.jonesdev.sonar.bungee.fallback.varint.Varint21FrameDecoder;
-import xyz.jonesdev.sonar.common.fallback.FallbackTimeoutHandler;
-
-import java.lang.reflect.Field;
-import java.util.concurrent.TimeUnit;
-
-import static net.md_5.bungee.netty.PipelineUtils.*;
-
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class BaseChannelInitializer extends ChannelInitializer<Channel> {
-  public static final BaseChannelInitializer INSTANCE = new BaseChannelInitializer();
-
-  private static final boolean REPLACE_VAR_INT_DECODER = !Boolean.getBoolean("sonar.do-not-replace-decoder");
-
-  private static final WriteBufferWaterMark MARK;
-  private static final Varint21LengthFieldPrepender FRAME_ENCODER;
-
-  static {
-    try {
-      final Field markField = PipelineUtils.class.getDeclaredField("MARK");
-      markField.setAccessible(true);
-      MARK = (WriteBufferWaterMark) markField.get(null);
-
-      final Field frameEncoder = PipelineUtils.class.getDeclaredField("framePrepender");
-      frameEncoder.setAccessible(true);
-      FRAME_ENCODER = (Varint21LengthFieldPrepender) frameEncoder.get(null);
-    } catch (Throwable throwable) {
-      throw new ReflectiveOperationException(throwable);
-    }
-  }
-
-  // Mostly taken from BungeeCord
-  // https://github.com/SpigotMC/BungeeCord/blob/master/proxy/src/main/java/net/md_5/bungee/netty/PipelineUtils.java#L162
-  @Override
-  protected void initChannel(final @NotNull Channel channel) throws Exception {
-    try {
-      channel.config().setOption(ChannelOption.IP_TOS, 0x18);
-    } catch (ChannelException ignored) {
-    }
-
-    channel.config().setOption(ChannelOption.TCP_NODELAY, true);
-    channel.config().setAllocator(PooledByteBufAllocator.DEFAULT);
-    channel.config().setWriteBufferWaterMark(MARK);
-
-    channel.pipeline().addLast(FRAME_DECODER, REPLACE_VAR_INT_DECODER
-      ? new Varint21FrameDecoder() : new net.md_5.bungee.protocol.Varint21FrameDecoder());
-    channel.pipeline().addLast(TIMEOUT_HANDLER, new FallbackTimeoutHandler(
-      BungeeCord.getInstance().config.getTimeout(), TimeUnit.MILLISECONDS
-    ));
-    channel.pipeline().addLast(FRAME_PREPENDER, FRAME_ENCODER);
-    channel.pipeline().addLast(BOSS_HANDLER, new HandlerBoss());
-  }
-}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/injection/ChildChannelInitializer.java

@@ -1,97 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback.injection;
-
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelInitializer;
-import io.netty.handler.codec.haproxy.HAProxyMessageDecoder;
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.config.ListenerInfo;
-import net.md_5.bungee.api.event.ClientConnectEvent;
-import net.md_5.bungee.netty.HandlerBoss;
-import net.md_5.bungee.netty.PipelineUtils;
-import net.md_5.bungee.protocol.*;
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.ReflectiveOperationException;
-import xyz.jonesdev.sonar.bungee.fallback.handler.FallbackInitialHandler;
-
-import java.lang.reflect.Field;
-import java.net.SocketAddress;
-
-import static net.md_5.bungee.netty.PipelineUtils.*;
-
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class ChildChannelInitializer extends ChannelInitializer<Channel> {
-  public static final ChildChannelInitializer INSTANCE = new ChildChannelInitializer();
-
-  private static final BaseChannelInitializer BASE = BaseChannelInitializer.INSTANCE;
-
-  private static final KickStringWriter LEGACY_KICK;
-
-  static {
-    try {
-      final Field kickField = PipelineUtils.class.getDeclaredField("legacyKicker");
-      kickField.setAccessible(true);
-      LEGACY_KICK = (KickStringWriter) kickField.get(null);
-    } catch (Throwable throwable) {
-      throw new ReflectiveOperationException(throwable);
-    }
-  }
-
-  // Mostly taken from BungeeCord
-  // https://github.com/SpigotMC/BungeeCord/blob/master/proxy/src/main/java/net/md_5/bungee/netty/PipelineUtils.java
-  @Override
-  protected void initChannel(final @NotNull Channel channel) throws Exception {
-    final SocketAddress remoteAddress = channel.remoteAddress() == null ? channel.parent().localAddress()
-      : channel.remoteAddress();
-
-    if (BungeeCord.getInstance().getConnectionThrottle() != null && BungeeCord.getInstance().getConnectionThrottle().throttle(remoteAddress)) {
-      channel.close();
-    } else {
-      final ListenerInfo listener = channel.attr(PipelineUtils.LISTENER).get();
-
-      if (BungeeCord.getInstance().getPluginManager().callEvent(new ClientConnectEvent(remoteAddress, listener)).isCancelled()) {
-        channel.close();
-      } else {
-        try {
-          BASE.initChannel(channel);
-        } catch (Exception exception) {
-          exception.printStackTrace(System.err);
-          channel.close();
-          return;
-        }
-
-        channel.pipeline().addBefore(FRAME_DECODER, LEGACY_DECODER, new LegacyDecoder());
-        channel.pipeline().addAfter(FRAME_DECODER, PACKET_DECODER, new MinecraftDecoder(Protocol.HANDSHAKE, true,
-          ProxyServer.getInstance().getProtocolVersion()));
-        channel.pipeline().addAfter(FRAME_PREPENDER, PACKET_ENCODER, new MinecraftEncoder(Protocol.HANDSHAKE,
-          true, ProxyServer.getInstance().getProtocolVersion()));
-        channel.pipeline().addBefore(FRAME_PREPENDER, LEGACY_KICKER, LEGACY_KICK);
-        channel.pipeline().get(HandlerBoss.class).setHandler(new FallbackInitialHandler(BungeeCord.getInstance(),
-          listener));
-
-        if (listener.isProxyProtocol()) {
-          channel.pipeline().addFirst(new HAProxyMessageDecoder());
-        }
-      }
-    }
-  }
-}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/varint/Varint21FrameDecoder.java

@@ -1,91 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback.varint;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.handler.codec.ByteToMessageDecoder;
-import io.netty.handler.codec.CorruptedFrameException;
-
-import java.util.List;
-
-// Mostly taken from
-// https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/netty/MinecraftVarintFrameDecoder.java
-public final class Varint21FrameDecoder extends ByteToMessageDecoder {
-
-  @Override
-  protected void decode(final ChannelHandlerContext ctx,
-                        final ByteBuf byteBuf,
-                        final List<Object> out) throws Exception {
-    if (!ctx.channel().isActive() || !byteBuf.isReadable()) {
-      // MessageToMessageDecoder always do release after decoding
-      // https://github.com/jonesdevelopment/sonar-legacy/pull/5
-      return;
-    }
-
-    final VarintByteDecoder reader = new VarintByteDecoder();
-    final int end = byteBuf.forEachByte(reader);
-
-    if (end == -1) {
-      // This is probably a good sign that the buffer was too short or empty
-      // since the ByteBuf cannot hold a proper VarInt.
-      if (reader.getResult() == VarintByteDecoder.DecoderResult.RUN_OF_ZEROES) {
-        byteBuf.clear();
-      }
-      return;
-    }
-
-    switch (reader.getResult()) {
-      case RUN_OF_ZEROES: {
-        // this will return to the point where the next varInt starts
-        byteBuf.readerIndex(end);
-        break;
-      }
-
-      case SUCCESS: {
-        final int readVarInt = reader.getReadVarInt();
-
-        if (readVarInt < 0) {
-          byteBuf.clear();
-          throw new CorruptedFrameException("Result: " + reader);
-        } else if (readVarInt == 0) {
-          // Actually, we don't want to throw an Exception if the packet is empty.
-          // The check would also false flag a lot of legit players since packets
-          // in 1.7 could sometimes be empty.
-          byteBuf.readerIndex(end + 1);
-          return;
-        }
-
-        final int bytesRead = reader.getBytesRead();
-        final int minimumRead = bytesRead + readVarInt;
-
-        if (byteBuf.isReadable(minimumRead)) {
-          out.add(byteBuf.retainedSlice(end + 1, readVarInt));
-
-          byteBuf.skipBytes(minimumRead);
-        }
-        break;
-      }
-
-      default: {
-        byteBuf.clear();
-        throw new CorruptedFrameException("Result: " + reader);
-      }
-    }
-  }
-}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/varint/VarintByteDecoder.java

@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback.varint;
-
-import io.netty.util.ByteProcessor;
-import lombok.Getter;
-import lombok.ToString;
-
-// Taken from
-// https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/netty/VarintByteDecoder.java
-@Getter
-@ToString
-public final class VarintByteDecoder implements ByteProcessor {
-  private DecoderResult result = DecoderResult.TOO_SMALL;
-  private int readVarInt, bytesRead;
-
-  @Override
-  public boolean process(byte b) throws Exception {
-    if (b == 0 && bytesRead == 0) {
-      result = DecoderResult.RUN_OF_ZEROES;
-      return true;
-    }
-
-    if (result == DecoderResult.RUN_OF_ZEROES) {
-      return false;
-    }
-
-    readVarInt |= (b & 0x7F) << bytesRead++ * 7;
-
-    if (bytesRead > 3) {
-      result = DecoderResult.TOO_BIG;
-      return false;
-    }
-
-    if ((b & 0x80) != 128) {
-      result = DecoderResult.SUCCESS;
-      return false;
-    }
-    return true;
-  }
-
-  public enum DecoderResult {
-    SUCCESS,
-    TOO_SMALL,
-    TOO_BIG,
-    RUN_OF_ZEROES
-  }
-}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/verbose/VerboseWrapper.java

@@ -1,43 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.verbose;
-
-import lombok.RequiredArgsConstructor;
-import net.md_5.bungee.api.ChatMessageType;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import xyz.jonesdev.sonar.api.verbose.Verbose;
-
-@RequiredArgsConstructor
-public final class VerboseWrapper extends Verbose {
-  private final ProxyServer server;
-
-  public void broadcast(final String message) {
-    final TextComponent component = new TextComponent(message);
-
-    synchronized (subscribers) {
-      for (final String subscriber : subscribers) {
-        final ProxiedPlayer player = server.getPlayer(subscriber);
-        if (player != null) {
-          player.sendMessage(ChatMessageType.ACTION_BAR, component);
-        }
-      }
-    }
-  }
-}

sonar-common/build.gradle.kts

@@ -2,5 +2,5 @@ dependencies {
   compileOnly(project(":api"))
 }
 
-java.sourceCompatibility = JavaVersion.VERSION_1_8
-java.targetCompatibility = JavaVersion.VERSION_1_8
+java.sourceCompatibility = JavaVersion.VERSION_11
+java.targetCompatibility = JavaVersion.VERSION_11

sonar-common/src/main/java/xyz/jonesdev/sonar/common/boot/LibraryLoader.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.boot;
+
+import com.alessiodp.libby.Library;
+import com.alessiodp.libby.LibraryManager;
+import lombok.experimental.UtilityClass;
+import org.jetbrains.annotations.NotNull;
+
+@UtilityClass
+class LibraryLoader {
+  void loadLibraries(final @NotNull LibraryManager libraryManager) {
+    libraryManager.addMavenCentral();
+    libraryManager.addJitPack();
+    libraryManager.loadLibraries(
+      // Simple-YAML
+      Library.builder()
+        .groupId("com{}github{}Carleslc{}Simple-YAML")
+        .artifactId("Simple-Yaml")
+        .version("1.8.4")
+        .relocate("com{}simpleyaml", "xyz{}jonesdev{}sonar{}libs{}yaml")
+        .build(),
+      // Gson
+      Library.builder()
+        .groupId("com{}google{}code{}gson")
+        .artifactId("gson")
+        .version("2.10.1")
+        .relocate("com{}google{}gson", "xyz{}jonesdev{}sonar{}libs{}gson")
+        .build(),
+      // Caffeine
+      Library.builder()
+        .groupId("com.github.ben-manes.caffeine")
+        .artifactId("caffeine")
+        .version("3.1.8")
+        .relocate("com{}github{}benmanes{}caffeine", "xyz{}jonesdev{}sonar{}libs{}caffeine")
+        .build(),
+      // ORMLite
+      Library.builder()
+        .groupId("com{}j256{}ormlite")
+        .artifactId("ormlite-jdbc")
+        .version("6.1")
+        .relocate("com{}j256{}ormlite", "xyz{}jonesdev{}sonar{}libs{}ormlite")
+        .build(),
+      // MySQL driver
+      Library.builder()
+        .groupId("com{}mysql")
+        .artifactId("mysql-connector-j")
+        .version("8.3.0")
+        .relocate("com{}mysql", "xyz{}jonesdev{}sonar{}libs{}mysql")
+        .build(),
+      // MariaDB driver
+      Library.builder()
+        .groupId("org{}mariadb{}jdbc")
+        .artifactId("mariadb-java-client")
+        .version("3.3.3")
+        .relocate("org{}mariadb", "xyz{}jonesdev{}sonar{}libs{}mariadb")
+        .build()
+    );
+  }
+}

sonar-common/src/main/java/xyz/jonesdev/sonar/common/boot/SonarBootstrap.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,26 +17,31 @@
 
 package xyz.jonesdev.sonar.common.boot;
 
+import com.alessiodp.libby.LibraryManager;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.j256.ormlite.logger.Level;
+import com.j256.ormlite.logger.Logger;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.cappuccino.Cappuccino;
-import xyz.jonesdev.cappuccino.ExpiringCache;
 import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.SonarPlatform;
 import xyz.jonesdev.sonar.api.SonarSupplier;
 import xyz.jonesdev.sonar.api.command.subcommand.SubcommandRegistry;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
 import xyz.jonesdev.sonar.api.controller.VerifiedPlayerController;
-import xyz.jonesdev.sonar.api.fallback.FallbackRatelimiter;
+import xyz.jonesdev.sonar.api.statistics.SonarStatistics;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
+import xyz.jonesdev.sonar.api.verbose.Notification;
 import xyz.jonesdev.sonar.api.verbose.Verbose;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
 import xyz.jonesdev.sonar.common.subcommand.SubcommandRegistryHolder;
+import xyz.jonesdev.sonar.common.update.UpdateChecker;
 
 import java.io.File;
-import java.net.InetAddress;
-import java.util.concurrent.TimeUnit;
+import java.time.Duration;
 
 @Getter
 @RequiredArgsConstructor
@@ -44,24 +49,38 @@ public abstract class SonarBootstrap<T> implements Sonar {
   private T plugin;
   @Setter
   private Verbose verboseHandler;
+  @Setter
+  private Notification notificationHandler;
   private SonarConfiguration config;
   private VerifiedPlayerController verifiedPlayerController;
   private File dataDirectory;
+  private final LibraryManager libraryManager;
+  private final SonarStatistics statistics;
+  private final SonarPlatform platform;
   private final SubcommandRegistry subcommandRegistry;
   private final SystemTimer launchTimer = new SystemTimer();
 
   public SonarBootstrap(final @NotNull T plugin,
+                        final LibraryManager libraryManager,
                         final File dataDirectory,
-                        final Verbose verboseHandler) {
-    // Set the API to this instance so the config doesn't have issues
+                        final SonarPlatform platform) {
+    // Set the Sonar API
     SonarSupplier.set(this);
-
-    // Set the plugin instance before anything else
+    // Store our library manager for the API
+    this.libraryManager = libraryManager;
+    // Load all libraries before anything else
+    LibraryLoader.loadLibraries(libraryManager);
+    // Set the plugin instance
     this.plugin = plugin;
     this.dataDirectory = dataDirectory;
-    this.verboseHandler = verboseHandler;
+    this.platform = platform;
+    this.statistics = new GlobalSonarStatistics();
+    this.verboseHandler = new Verbose();
+    this.notificationHandler = new Notification();
     this.config = new SonarConfiguration(dataDirectory);
     this.subcommandRegistry = new SubcommandRegistryHolder();
+    // Hide unnecessary debug information
+    Logger.setGlobalLogLevel(Level.WARNING);
   }
 
   public final void initialize() {
@@ -90,8 +109,12 @@ public abstract class SonarBootstrap<T> implements Sonar {
     } catch (Throwable throwable) {
       // An error has occurred
       getLogger().error("An error has occurred while launching Sonar: {}", throwable);
-      throwable.printStackTrace();
+      throwable.printStackTrace(System.err);
+      return; // Do not check for updates if the launch failed
     }
+
+    // Check if a new version has been released
+    UpdateChecker.checkForUpdates();
   }
 
   public abstract void enable();
@@ -101,33 +124,55 @@ public abstract class SonarBootstrap<T> implements Sonar {
     getConfig().load();
 
     // Warn player if they reloaded and changed the database type
-    if (getVerifiedPlayerController() != null
-      && getVerifiedPlayerController().getCachedDatabaseType() != getConfig().getDatabaseType()) {
-      Sonar.get().getLogger().warn("Reloading the server after changing the database type"
-        + " is generally not recommended as it can sometimes cause data loss.");
+    if (verifiedPlayerController != null
+      && verifiedPlayerController.getCachedDatabaseType() != getConfig().getDatabase().getType()) {
+      getLogger().warn("Reloading after changing the database type is not recommended as it may cause data loss.");
     }
 
     // Prepare cached packets
     FallbackPreparer.prepare();
 
-    // Update ratelimiter
-    final ExpiringCache<InetAddress> expiringCache = Cappuccino.buildExpiring(
-      getConfig().getVerificationDelay(), TimeUnit.MILLISECONDS, 250L
-    );
-    FallbackRatelimiter.INSTANCE.setExpiringCache(expiringCache);
+    // Update ratelimiter cache
+    getFallback().getRatelimiter().setExpiringCache(Caffeine.newBuilder()
+      .expireAfterWrite(Duration.ofMillis(getConfig().getVerification().getReconnectDelay()))
+      .build());
+
+    // Update blacklist cache
+    final long blacklistTime = getConfig().getVerification().getBlacklistTime();
+    final boolean blacklistExists = getFallback().getBlacklist() != null;
+    // Make sure the blacklist is only set when we need it to prevent data loss
+    if (!blacklistExists // Make sure we create a new cache if it doesn't exist yet
+      || getFallback().getBlacklistTime() != blacklistTime) {
+      // Create new cache with the configured blacklist time
+      getFallback().setBlacklist(Caffeine.newBuilder()
+        .expireAfterWrite(Duration.ofMillis(getConfig().getVerification().getBlacklistTime()))
+        .build());
+      // Store the new blacklist time, so we don't have to reset the blacklist every reload
+      getFallback().setBlacklistTime(blacklistTime);
+      // Warn the user about changing the expiry of the blacklist values
+      if (blacklistExists) {
+        getLogger().warn("The blacklist has been reset as the duration of entries has changed.");
+      }
+    }
 
     // Reinitialize database controller
+    if (verifiedPlayerController != null) {
+      // Close the old connection first
+      verifiedPlayerController.close();
+    }
     verifiedPlayerController = new VerifiedPlayerController();
-
-    // Call post reload task
-    postReload();
   }
 
-  public abstract void postReload();
-
-  public void shutdown() {
+  public final void shutdown() {
+    // Initialize shutdown process
     getLogger().info("Starting shutdown process...");
-    // ...
+    // Close database connection
+    verifiedPlayerController.close();
+    // Run the per-platform disable method
+    disable();
+    // Thank the user for using Sonar
     getLogger().info("Successfully shut down. Goodbye!");
   }
+
+  public abstract void disable();
 }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackBandwidthHandler.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+
+import static xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics.INCOMING;
+import static xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics.OUTGOING;
+
+@ChannelHandler.Sharable
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class FallbackBandwidthHandler extends ChannelDuplexHandler {
+  public static final ChannelHandler INSTANCE = new FallbackBandwidthHandler();
+
+  @Override
+  public void channelRead(final @NotNull ChannelHandlerContext ctx,
+                          final @NotNull Object msg) throws Exception {
+    // We can only get the size of a message if it's a ByteBuf
+    if (msg instanceof ByteBuf) {
+      // Increment the incoming traffic by the amount of readable bytes
+      INCOMING.increment(((ByteBuf) msg).readableBytes());
+    }
+    // Make sure to let the server handle the rest
+    ctx.fireChannelRead(msg);
+  }
+
+  @Override
+  public void write(final @NotNull ChannelHandlerContext ctx,
+                    final @NotNull Object msg,
+                    final ChannelPromise promise) throws Exception {
+    // We can only get the size of a message if it's a ByteBuf
+    if (msg instanceof ByteBuf) {
+      // Increment the outgoing traffic by the amount of readable bytes
+      OUTGOING.increment(((ByteBuf) msg).readableBytes());
+    }
+    // Make sure to let the server handle the rest
+    ctx.write(msg, promise);
+  }
+}

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackChannelHandler.java

@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.common.fallback;
-
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelInboundHandlerAdapter;
-import lombok.RequiredArgsConstructor;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.fallback.Fallback;
-
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-
-@RequiredArgsConstructor
-public final class FallbackChannelHandler extends ChannelInboundHandlerAdapter {
-  private static final Fallback FALLBACK = Sonar.get().getFallback();
-  private final String username;
-
-  @Override
-  public void channelUnregistered(final ChannelHandlerContext ctx) {
-    final InetAddress inetAddress = ((InetSocketAddress) ctx.channel().remoteAddress()).getAddress();
-
-    // Remove the IP address from the queue
-    FALLBACK.getConnected().remove(username);
-    FALLBACK.getQueue().remove(inetAddress);
-
-    ctx.fireChannelUnregistered();
-  }
-}

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackChannelHandlerAdapter.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.fallback.Fallback;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
+
+import java.net.InetAddress;
+
+@RequiredArgsConstructor
+public class FallbackChannelHandlerAdapter extends ChannelInboundHandlerAdapter {
+  protected final Channel channel;
+  protected @Nullable String username;
+  protected InetAddress inetAddress;
+  protected ProtocolVersion protocolVersion;
+
+  protected static final Fallback FALLBACK = Sonar.get().getFallback();
+
+  @Override
+  public final void channelActive(final @NotNull ChannelHandlerContext ctx) {
+    // Increase connections per second for the action bar verbose
+    GlobalSonarStatistics.countConnection();
+    // Make sure to let the server handle the rest
+    ctx.fireChannelActive();
+  }
+
+  @Override
+  public final void channelInactive(final @NotNull ChannelHandlerContext ctx) {
+    // The player can disconnect without sending the login packet first
+    if (username != null) {
+      // Remove the username from the connected players
+      FALLBACK.getConnected().remove(username);
+    }
+    // The player cannot be in the queue if the IP address is invalid
+    if (inetAddress != null) {
+      // Remove the IP address from the queue
+      FALLBACK.getQueue().remove(inetAddress);
+    }
+    // Make sure to let the server handle the rest
+    ctx.fireChannelInactive();
+  }
+
+  // We can override the default exceptionCaught method since this handler
+  // will run before the connection knows that there has been an error.
+  // Additionally, this will also run after our custom decoder.
+  @Override
+  public final void exceptionCaught(final @NotNull ChannelHandlerContext ctx,
+                                    final @NotNull Throwable cause) throws Exception {
+    // Simply close the channel if we encounter any errors.
+    ctx.close();
+  }
+}

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackTimeoutHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,24 +21,26 @@ import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.timeout.IdleState;
 import io.netty.handler.timeout.IdleStateEvent;
 import io.netty.handler.timeout.IdleStateHandler;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.concurrent.TimeUnit;
 
 public final class FallbackTimeoutHandler extends IdleStateHandler {
-  private boolean closed;
+  private boolean knownDisconnect;
 
   public FallbackTimeoutHandler(final long timeout, final TimeUnit timeUnit) {
     super(timeout, 0L, 0L, timeUnit);
   }
 
   @Override
-  protected void channelIdle(final ChannelHandlerContext ctx, final IdleStateEvent idleStateEvent) throws Exception {
+  protected void channelIdle(final ChannelHandlerContext ctx,
+                             final @NotNull IdleStateEvent idleStateEvent) throws Exception {
     assert idleStateEvent.state() == IdleState.READER_IDLE;
     readTimedOut(ctx);
   }
 
   private void readTimedOut(final ChannelHandlerContext ctx) {
-    if (!closed) {
+    if (!knownDisconnect) {
 
       // The netty (default) ReadTimeoutHandler would normally just throw an Exception
       // The default ReadTimeoutHandler does only check for the boolean 'closed' and
@@ -47,7 +49,7 @@ public final class FallbackTimeoutHandler extends IdleStateHandler {
         ctx.close();
       }
 
-      closed = true;
+      knownDisconnect = true;
     }
   }
 }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackUserWrapper.java

@@ -0,0 +1,253 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelPipeline;
+import lombok.Getter;
+import lombok.ToString;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.event.impl.UserBlacklistedEvent;
+import xyz.jonesdev.sonar.api.event.impl.UserVerifyFailedEvent;
+import xyz.jonesdev.sonar.api.event.impl.UserVerifyJoinEvent;
+import xyz.jonesdev.sonar.api.fallback.FallbackUser;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketDecoder;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketEncoder;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginSuccessPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.DisconnectPacket;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
+
+import java.net.InetAddress;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.*;
+
+@Getter
+@ToString(of = {"protocolVersion", "inetAddress"})
+public final class FallbackUserWrapper implements FallbackUser {
+  private final Channel channel;
+  private final ChannelPipeline pipeline;
+  private final InetAddress inetAddress;
+  private final ProtocolVersion protocolVersion;
+
+  public FallbackUserWrapper(final @NotNull Channel channel,
+                             final @NotNull InetAddress inetAddress,
+                             final @NotNull ProtocolVersion protocolVersion) {
+    this.channel = channel;
+    this.pipeline = channel.pipeline();
+    this.inetAddress = inetAddress;
+    this.protocolVersion = protocolVersion;
+  }
+
+  @Override
+  public void disconnect(final @NotNull Component reason) {
+    closeWith(channel, protocolVersion, DisconnectPacket.create(reason, false));
+  }
+
+  @Override
+  public void hijack(final @NotNull String username, final @NotNull UUID uuid,
+                     final @NotNull String encoder, final @NotNull String decoder,
+                     final @NotNull String timeout, final @NotNull String boss) {
+    // This rarely happens when the channel hangs, but the player is still connecting
+    // This also fixes a unique issue with TCPShield and other reverse proxies
+    if (pipeline.get(encoder) == null || pipeline.get(decoder) == null) {
+      channel.close();
+      return;
+    }
+
+    // Remove main pipeline to completely take over the channel
+    if (pipeline.get(boss) != null) {
+      pipeline.remove(boss);
+    }
+
+    // The player has joined the verification
+    GlobalSonarStatistics.totalAttemptedVerifications++;
+
+    if (Sonar.get().getConfig().getVerification().isLogConnections()) {
+      // Only log the processing message if the server isn't under attack.
+      // We let the user override this through the configuration.
+      if (!Sonar.get().getAttackTracker().isCurrentlyUnderAttack()
+        || Sonar.get().getConfig().getVerification().isLogDuringAttack()) {
+        Sonar.get().getFallback().getLogger().info(Sonar.get().getConfig().getVerification().getConnectLog()
+          .replace("%name%", username)
+          .replace("%ip%", Sonar.get().getConfig().formatAddress(inetAddress))
+          .replace("%protocol%", String.valueOf(protocolVersion.getProtocol())));
+      }
+    }
+
+    // Call the VerifyJoinEvent for external API usage
+    Sonar.get().getEventManager().publish(new UserVerifyJoinEvent(username, this));
+
+    // Mark the player as connected → verifying players
+    Sonar.get().getFallback().getConnected().put(username, inetAddress);
+
+    // Add better timeout handler to avoid known exploits or issues
+    // We also want to timeout bots quickly to avoid flooding
+    final int readTimeout = Sonar.get().getConfig().getVerification().getReadTimeout();
+    pipeline.replace(timeout, timeout, new FallbackTimeoutHandler(readTimeout, TimeUnit.MILLISECONDS));
+
+    // Replace normal encoder to allow custom packets
+    final FallbackPacketEncoder newEncoder = new FallbackPacketEncoder(protocolVersion);
+    pipeline.replace(encoder, FALLBACK_PACKET_ENCODER, newEncoder);
+
+    // Send LoginSuccess packet to make the client think they are joining the server
+    write(new LoginSuccessPacket(username, uuid));
+
+    // The LoginSuccess packet has been sent, now we can change the registry state
+    newEncoder.updateRegistry(protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_20_2) >= 0
+      ? FallbackPacketRegistry.CONFIG : FallbackPacketRegistry.GAME);
+
+    // Replace normal decoder to allow custom packets
+    pipeline.replace(decoder, FALLBACK_PACKET_DECODER,
+      new FallbackPacketDecoder(this, new FallbackVerificationHandler(this, username, uuid)));
+  }
+
+  @Override
+  public void fail(final @Nullable String reason) {
+    if (channel.isActive()) {
+      disconnect(Sonar.get().getConfig().getVerification().getVerificationFailed());
+
+      if (reason != null) {
+        // Only log the failed message if the server isn't under attack.
+        // We let the user override this through the configuration.
+        if (!Sonar.get().getAttackTracker().isCurrentlyUnderAttack()
+          || Sonar.get().getConfig().getVerification().isLogDuringAttack()) {
+          Sonar.get().getFallback().getLogger().info(Sonar.get().getConfig().getVerification().getFailedLog()
+            .replace("%ip%", Sonar.get().getConfig().formatAddress(getInetAddress()))
+            .replace("%protocol%", String.valueOf(getProtocolVersion().getProtocol()))
+            .replace("%reason%", reason));
+        }
+      }
+    }
+
+    // Increment amount of total failed verifications
+    GlobalSonarStatistics.totalFailedVerifications++;
+
+    // Call the VerifyFailedEvent for external API usage
+    Sonar.get().getEventManager().publish(new UserVerifyFailedEvent(this, reason));
+
+    // Use a label, so we can easily add more code beneath this method
+    blacklist: {
+      // Check if the player has too many failed attempts
+      final int blacklistThreshold = Sonar.get().getConfig().getVerification().getBlacklistThreshold();
+      // The user is allowed to disable the blacklist entirely by setting the threshold to 0
+      if (blacklistThreshold <= 0) break blacklist;
+
+      // Add 1 to the amount of fails since we haven't updated the cached entries yet (for performance)
+      final int failCount = getFailedCount() + 1;
+      // Now we simply need to check if the threshold is reached
+      if (failCount >= blacklistThreshold) {
+        // Call the BotBlacklistedEvent for external API usage
+        Sonar.get().getEventManager().publish(new UserBlacklistedEvent(this));
+
+        // Increment amount of total blacklisted players
+        GlobalSonarStatistics.totalBlacklistedPlayers++;
+
+        Sonar.get().getFallback().getBlacklist().put(getInetAddress(), (byte) 0);
+        Sonar.get().getFallback().getLogger().info(Sonar.get().getConfig().getVerification().getBlacklistLog()
+          .replace("%ip%", Sonar.get().getConfig().formatAddress(getInetAddress()))
+          .replace("%protocol%", String.valueOf(getProtocolVersion().getProtocol())));
+
+        // Invalidate the cached entry to ensure memory safety
+        invalidateFails();
+        break blacklist;
+      }
+
+      // Make sure we increment the number of fails
+      incrementFails();
+    }
+  }
+
+  /**
+   * @param channel         Channel to close
+   * @param protocolVersion Protocol version
+   * @param msg             Packet to close the channel with
+   */
+  public static void closeWith(final @NotNull Channel channel,
+                               final @NotNull ProtocolVersion protocolVersion,
+                               final @NotNull Object msg) {
+    if (channel.isActive()) {
+      if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_8) < 0
+        && protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_7_2) >= 0) {
+        channel.eventLoop().execute(() -> {
+          channel.config().setAutoRead(false);
+          channel.eventLoop().schedule(() -> {
+            channel.writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
+          }, 250L, TimeUnit.MILLISECONDS);
+        });
+      } else {
+        channel.writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
+      }
+    }
+  }
+
+  /**
+   * Disconnect the player before verification (during login)
+   * by replacing the encoder before running the method.
+   *
+   * @param packet          Disconnect packet
+   * @param encoder         Encoder to replace
+   * @param boss            Main pipeline to remove
+   * @param channel         Channel of the player
+   * @param protocolVersion Protocol version of the player
+   */
+  public static void customDisconnect(final @NotNull Channel channel,
+                                      final @NotNull ProtocolVersion protocolVersion,
+                                      final @NotNull FallbackPacket packet,
+                                      final @NotNull String encoder,
+                                      final @NotNull String boss) {
+    // Remove main pipeline to completely take over the channel
+    if (channel.pipeline().get(boss) != null) {
+      channel.pipeline().remove(boss);
+    }
+    final ChannelHandler currentEncoder = channel.pipeline().get(encoder);
+    // Simply close the channel if no decoder exists
+    if (currentEncoder != null) {
+      // We don't need to update the encoder if it's already present
+      if (!(currentEncoder instanceof FallbackPacketEncoder)) {
+        final FallbackPacketEncoder newEncoder = new FallbackPacketEncoder(protocolVersion);
+        channel.pipeline().replace(encoder, FALLBACK_PACKET_ENCODER, newEncoder);
+      }
+      closeWith(channel, protocolVersion, packet);
+    } else {
+      channel.close();
+    }
+  }
+
+  /**
+   * Removes Sonar's pipelines from a channel to save
+   * unnecessary RAM and CPU usage
+   *
+   * @param pipeline Pipeline object of the channel
+   */
+  public static void deject(final @NotNull ChannelPipeline pipeline) {
+    // Remove Sonar's pipelines if they exist
+    if (pipeline.get(FALLBACK_HANDLER) != null) {
+      pipeline.remove(FALLBACK_HANDLER);
+    }
+  }
+}

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackVerificationHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,78 +20,128 @@ package xyz.jonesdev.sonar.common.fallback;
 import io.netty.buffer.ByteBuf;
 import io.netty.handler.codec.CorruptedFrameException;
 import io.netty.handler.codec.DecoderException;
-import lombok.RequiredArgsConstructor;
-import lombok.Setter;
+import lombok.val;
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.event.impl.UserVerifySuccessEvent;
+import xyz.jonesdev.sonar.api.fallback.Fallback;
 import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 import xyz.jonesdev.sonar.api.model.VerifiedPlayer;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
-import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
-import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketListener;
-import xyz.jonesdev.sonar.common.fallback.protocol.packets.*;
+import xyz.jonesdev.sonar.common.fallback.protocol.*;
+import xyz.jonesdev.sonar.common.fallback.protocol.map.ItemMapType;
+import xyz.jonesdev.sonar.common.fallback.protocol.map.MapInfoPreparer;
+import xyz.jonesdev.sonar.common.fallback.protocol.map.PreparedMapInfo;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.FinishConfigurationPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginAcknowledgedPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
 import xyz.jonesdev.sonar.common.utility.protocol.ProtocolUtil;
 
+import java.util.Objects;
 import java.util.Random;
 import java.util.UUID;
 import java.util.regex.Pattern;
 
-import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT_1_13;
-import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT_1_8;
+import static xyz.jonesdev.sonar.api.config.SonarConfiguration.Verification.Gravity.Gamemode.CREATIVE;
+import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_PACKET_DECODER;
+import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_PACKET_ENCODER;
+import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.*;
 import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer.*;
 
 public final class FallbackVerificationHandler implements FallbackPacketListener {
-  private final @NotNull FallbackUser<?, ?> user;
-  private final String username;
-  private final UUID uuid;
-  private final short transactionId;
-  private final long verifyKeepAliveId;
-  private int movementTick, receivedPackets;
-  private double lastX, lastY, lastZ;
-  @Setter
-  private State state;
-
-  private final SystemTimer login = new SystemTimer();
   private static final Random RANDOM = new Random();
+  private static final Fallback FALLBACK = Sonar.get().getFallback();
+
+  // General
+  private final SystemTimer login = new SystemTimer();
+  private final @NotNull FallbackUser user;
+  private final String username;
+  private final UUID playerUuid;
+  private @NotNull State state = State.LOGIN_ACK; // 1.20.2
+
+  // Checks
+  private short expectedTransactionId;
+  private int expectedKeepAliveId, expectedTeleportId = -1;
+  private int tick, totalReceivedPackets, ignoredMovementTicks;
+  private double posX, posY, posZ, lastY, spawnYPosition;
+  private boolean resolvedClientBrand, resolvedClientSettings;
+  private boolean listenForMovements;
+
+  // Map captcha
+  private final SystemTimer keepAlive = new SystemTimer();
+  private final SystemTimer actionBar = new SystemTimer();
+  private @Nullable PreparedMapInfo captcha;
+  private int captchaTriesLeft;
 
-  @RequiredArgsConstructor
   public enum State {
-    // LOGIN
-    KEEP_ALIVE(false),
-    // PLAY
-    CLIENT_SETTINGS(false),
-    PLUGIN_MESSAGE(false),
-    TRANSACTION(false),
-    // IN-GAME
-    TELEPORT(false),
-    POSITION(true),
-    COLLISIONS(true),
-    // OTHER
-    SUCCESS(false);
-
-    private final boolean canMove;
+    // 1.20.2 configuration state
+    LOGIN_ACK, CONFIGURE,
+    // pre-JOIN ping check
+    KEEP_ALIVE,
+    // post-JOIN checks
+    CLIENT_SETTINGS, PLUGIN_MESSAGE, TRANSACTION,
+    // PLAY checks
+    TELEPORT, POSITION,
+    // Captcha
+    MAP_CAPTCHA,
+    // Done
+    SUCCESS
   }
 
-  public FallbackVerificationHandler(final @NotNull FallbackUser<?, ?> user,
+  public FallbackVerificationHandler(final @NotNull FallbackUser user,
                                      final @NotNull String username,
-                                     final @NotNull UUID uuid) {
+                                     final @NotNull UUID playerUuid) {
     this.user = user;
     this.username = username;
-    this.uuid = uuid;
-    this.transactionId = (short) RANDOM.nextInt();
-    this.verifyKeepAliveId = RANDOM.nextInt();
-    this.state = State.KEEP_ALIVE;
+    this.playerUuid = playerUuid;
 
-    // Send LoginSuccess packet to make the client think they are joining the server
-    user.write(new ServerLoginSuccess(username, uuid));
+    if (user.getProtocolVersion().compareTo(MINECRAFT_1_20_2) < 0) {
+      // Start initializing the actual join process
+      initialJoinProcess();
+    }
+  }
 
+  private void configure() {
+    // Set the state to CONFIGURE to avoid false positives
+    state = State.CONFIGURE;
+    // Send the necessary configuration packets to the client
+    user.delayedWrite(REGISTRY_SYNC);
+    user.delayedWrite(FINISH_CONFIGURATION);
+    // Send all packets in one flush
+    user.getChannel().flush();
+    // Set decoder state to actually catch all packets
+    updateEncoderDecoderState(FallbackPacketRegistry.CONFIG);
+  }
+
+  private void updateEncoderDecoderState(final @NotNull FallbackPacketRegistry registry) {
+    val decoder = (FallbackPacketDecoder) user.getChannel().pipeline().get(FALLBACK_PACKET_DECODER);
+    val encoder = (FallbackPacketEncoder) user.getChannel().pipeline().get(FALLBACK_PACKET_ENCODER);
+    if (decoder != null && encoder != null) {
+      // Update the packet registry state to be able to listen for CONFIG packets
+      decoder.updateRegistry(registry);
+      encoder.updateRegistry(registry);
+    } else {
+      // Something went wrong - the decoder should not be null
+      FALLBACK.getLogger().warn("Necessary pipelines for {} not found", username);
+      // Close the channel to prevent bypasses or other potential exploits
+      user.getChannel().close();
+    }
+  }
+
+  private void initialJoinProcess() {
     if (user.getProtocolVersion().compareTo(MINECRAFT_1_8) < 0) {
       // 1.7 players don't have KeepAlive packets in the login process
       sendJoinGamePacket();
     } else {
+      // Set the state to KEEP_ALIVE to avoid false positives
+      state = State.KEEP_ALIVE;
+      // Generate a random KeepAlive ID for the pre-join check
+      expectedKeepAliveId = RANDOM.nextInt();
       // Send first KeepAlive to check if the connection is somewhat responsive
-      user.write(new KeepAlive(verifyKeepAliveId));
+      user.write(new KeepAlivePacket(expectedKeepAliveId));
     }
   }
 
@@ -99,50 +149,102 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     // Set the state to TRANSACTION to avoid false positives
     // and go on with the flow of the verification.
     state = State.TRANSACTION;
-    // Send a transaction with a
-    user.write(new Transaction(
-      0, transactionId, false
-    ));
+    // Generate a random transaction ID
+    expectedTransactionId = (short) RANDOM.nextInt();
+    // Send a transaction with the given ID
+    user.write(new TransactionPacket(0, expectedTransactionId, false));
   }
 
   private void sendJoinGamePacket() {
-    // Set the state to CLIENT_SETTINGS to avoid false positives
+    final boolean v1_20_2 = user.getProtocolVersion().compareTo(MINECRAFT_1_20_2) >= 0;
+    if (!v1_20_2) {
+      // Set the state to CLIENT_SETTINGS to avoid false positives
+      // (1.20.2 needs the LOGIN_ACK state) and go on with
+      // the flow of the verification.
+      state = State.CLIENT_SETTINGS;
+    }
+    // Send the JoinGame packet so we can continue the verification
+    user.write(joinGame);
+    if (v1_20_2) {
+      // Perform the transaction check since the ClientSettings
+      // and PluginMessage packets have already been validated.
+      sendTransaction();
+    }
+  }
+
+  private void sendAbilitiesAndTeleport() {
+    // Set the state to TELEPORT to avoid false positives
     // and go on with the flow of the verification.
-    state = State.CLIENT_SETTINGS;
-    // Select the JoinGame packet for the respective protocol version
-    user.write(getJoinPacketForVersion(user.getProtocolVersion()));
+    state = State.TELEPORT;
+    // Make sure the player is unable to fly (e.g. if the player is in creative mode)
+    if (Sonar.get().getConfig().getVerification().getGravity().getGamemode() == CREATIVE) {
+      user.delayedWrite(DEFAULT_ABILITIES);
+    }
+    // Generate the current teleport ID
+    expectedTeleportId = RANDOM.nextInt();
+    // Add a little randomization to the spawn y coordinate
+    spawnYPosition = dynamicSpawnYPosition + RANDOM.nextDouble(0.4);
+    // Teleport the player to the spawn position
+    user.delayedWrite(new PlayerPositionLookPacket(
+      SPAWN_X_POSITION, spawnYPosition, SPAWN_Z_POSITION,
+      0f, -90f, expectedTeleportId, false));
+    // Make sure the player escapes the 1.18.2+ "Loading terrain" screen
+    if (user.getProtocolVersion().compareTo(MINECRAFT_1_18_2) >= 0) {
+      user.delayedWrite(dynamicSpawnPosition);
+    }
   }
 
   private void sendChunkData() {
+    // If we don't have gravity and captcha enabled, simply finish verification
+    if (!Sonar.get().getConfig().getVerification().getGravity().isEnabled()
+      && !FALLBACK.shouldDoMapCaptcha()) {
+      // Save some work by finishing before sending even more packets
+      finish();
+      return;
+    }
     // Set the state to POSITION to avoid false positives
     // and go on with the flow of the verification.
     state = State.POSITION;
+    // 1.20.3 packets introduced game events
+    if (user.getProtocolVersion().compareTo(MINECRAFT_1_20_3) >= 0) {
+      // Make sure the client knows that we're sending chunks next
+      user.delayedWrite(START_WRITING_CHUNKS);
+    }
     // Teleport player into the fake lobby by sending an empty chunk
-    user.write(EMPTY_CHUNK_DATA);
+    user.delayedWrite(EMPTY_CHUNK_DATA);
+    // Checking gravity is disabled, just finish verification
+    if (!Sonar.get().getConfig().getVerification().getGravity().isEnabled()) {
+      // Switch to captcha state if needed
+      captchaOrFinish();
+      return;
+    }
     // Send an UpdateSectionBlocks packet with a platform of blocks
     // to check if the player collides with the solid platform.
-    user.write(UPDATE_SECTION_BLOCKS);
+    user.delayedWrite(updateSectionBlocks);
+    // Send all packets in one flush
+    user.getChannel().flush();
   }
 
-  private static boolean validateClientLocale(final @SuppressWarnings("unused") @NotNull FallbackUser<?, ?> user,
+  private static boolean validateClientLocale(final @SuppressWarnings("unused") @NotNull FallbackUser user,
                                               final String locale) {
     // Check the client locale by performing a simple regex check on it
-    final Pattern pattern = Sonar.get().getConfig().getValidLocaleRegex();
+    final Pattern pattern = Sonar.get().getConfig().getVerification().getValidLocaleRegex();
     return pattern.matcher(locale).matches(); // Disallow non-ascii characters (by default)
   }
 
-  private static boolean validateClientBrand(final @NotNull FallbackUser<?, ?> user, final ByteBuf content) {
+  private static boolean validateClientBrand(final @NotNull FallbackUser user, final ByteBuf content) {
     // We have to catch every DecoderException, so we can fail and punish
     // the player instead of only disconnecting them due to an exception.
     try {
-      // 1.7 has some very weird issues when trying to decode the client brand
-      // TODO: fix this?
-      if (user.getProtocolVersion().compareTo(MINECRAFT_1_8) < 0) return true;
-      // No need to check for empty or too long client brands since
-      // ProtocolUtil#readString already does exactly that.
-      final String read = ProtocolUtil.readString(content, Sonar.get().getConfig().getMaximumBrandLength());
+      // No need to check for empty brands since ProtocolUtil#readBrandMessage
+      // already performs these checks by default.
+      final String read = ProtocolUtil.readBrandMessage(content);
+      // Check if the decoded client brand string is too long
+      if (read.length() > Sonar.get().getConfig().getVerification().getBrand().getMaxLength()) {
+        return false;
+      }
       // Regex pattern for validating client brands
-      final Pattern pattern = Sonar.get().getConfig().getValidBrandRegex();
+      final Pattern pattern = Sonar.get().getConfig().getVerification().getBrand().getValidRegex();
       return !read.equals("Vanilla") // The normal brand is always lowercase
         && pattern.matcher(read).matches(); // Disallow non-ascii characters (by default)
     } catch (DecoderException exception) {
@@ -153,23 +255,92 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     }
   }
 
-  @Override
-  public void handle(final @NotNull FallbackPacket packet) {
-    // Check if the player is not sending a ton of packets to the server
-    final int maxPackets = Sonar.get().getConfig().getMaximumLoginPackets()
-      + Sonar.get().getConfig().getMaximumMovementTicks();
-    checkFrame(++receivedPackets < maxPackets, "too many packets");
+  private void handlePacketDuringCaptcha(final @NotNull FallbackPacket packet) {
+    // Check if the player took too long to enter the captcha
+    final int maxDuration = Sonar.get().getConfig().getVerification().getMap().getMaxDuration();
+    checkFrame(!login.elapsed(maxDuration), "took too long to enter captcha");
 
-    // Check for timeout since the player could be sending packets but not important ones
-    final long timeout = Sonar.get().getConfig().getVerificationTimeout();
-    // Check if the time limit has exceeded
-    if (login.elapsed(timeout)) {
-      user.getChannel().close();
+    // Handle incoming chat messages
+    if (packet instanceof UniversalChatPacket) {
+      final UniversalChatPacket chat = (UniversalChatPacket) packet;
+      Objects.requireNonNull(captcha);
+      if (!chat.getMessage().equals(captcha.getInfo().getAnswer())) {
+        // Captcha is incorrect
+        checkFrame(captchaTriesLeft-- > 0, "failed captcha too often");
+        user.write(incorrectCaptcha);
+        return;
+      }
+      // Captcha is correct
+      finish();
       return;
     }
 
-    if (packet instanceof KeepAlive) {
-      final KeepAlive keepAlive = (KeepAlive) packet;
+    // Every second
+    if (actionBar.elapsed(1000L)) {
+      final String actionBarMessage = Sonar.get().getConfig().getVerification().getMap().getEnterCodeActionBar();
+      // Only send action bar if the message is actually supposed to be sent
+      if (!actionBarMessage.isEmpty()) {
+        final String timeLeft = String.format("%.0f", (maxDuration - login.delay()) / 1000D);
+        user.write(new UniversalChatPacket(MiniMessage.miniMessage().deserialize(
+          actionBarMessage.replace("%time-left%", timeLeft)), UniversalChatPacket.GAME_INFO_TYPE));
+        // Make sure to reset the timer
+        actionBar.reset();
+      }
+    }
+
+    // Every 10 seconds
+    if (keepAlive.elapsed(10_000L)) {
+      // Send a KeepAlive packet to prevent timeout
+      user.delayedWrite(CAPTCHA_KEEP_ALIVE);
+      // Send both packets in one flush
+      user.getChannel().flush();
+      // Make sure to reset the timer
+      keepAlive.reset();
+    }
+  }
+
+  @Override
+  public void handle(final @NotNull FallbackPacket packet) {
+    // The player has already been verified, drop all other packets
+    if (state == State.SUCCESS) return;
+
+    // We are expecting a captcha code in chat, drop all other packets
+    if (state == State.MAP_CAPTCHA) {
+      handlePacketDuringCaptcha(packet);
+      return;
+    }
+
+    // Check if the player is not sending a ton of packets to the server
+    final int maxPackets = Sonar.get().getConfig().getVerification().getMaxLoginPackets() + maxMovementTick;
+    checkFrame(++totalReceivedPackets < maxPackets, "too many packets");
+
+    // Check for timeout since the player could be sending packets but not important ones
+    final long timeout = Sonar.get().getConfig().getVerification().getMaxPing();
+    checkFrame(!login.elapsed(timeout), "time limit exceeded");
+
+    if (packet instanceof LoginAcknowledgedPacket) {
+      // Check if we are currently expecting a LoginAcknowledged packet
+      assertState(State.LOGIN_ACK);
+
+      // Start the configuration process for 1.20.2 clients
+      configure();
+    }
+
+    if (packet instanceof FinishConfigurationPacket) {
+      // Check if we are currently expecting a FinishConfiguration packet
+      assertState(State.CONFIGURE);
+
+      // Check if the client has already sent valid ClientSettings and PluginMessage packets
+      checkFrame(resolvedClientBrand, "did not resolve client brand");
+      checkFrame(resolvedClientSettings, "did not resolve client settings");
+
+      // Start initializing the actual join process
+      updateEncoderDecoderState(FallbackPacketRegistry.GAME);
+      initialJoinProcess();
+    }
+
+    if (packet instanceof KeepAlivePacket) {
+      final KeepAlivePacket keepAlive = (KeepAlivePacket) packet;
 
       // 1.7-1.8.9 are sending a KeepAlive packet with the ID 0 every 20 ticks
       if (keepAlive.getId() == 0 && user.getProtocolVersion().compareTo(MINECRAFT_1_8) <= 0) return;
@@ -177,14 +348,14 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
       // Check if we are currently expecting a KeepAlive packet
       assertState(State.KEEP_ALIVE);
 
-      checkFrame(keepAlive.getId() == verifyKeepAliveId, "invalid KeepAlive ID");
+      checkFrame(keepAlive.getId() == expectedKeepAliveId, "invalid KeepAlive ID");
 
       // The correct KeepAlive packet has been received
       sendJoinGamePacket();
     }
 
-    if (packet instanceof ClientSettings) {
-      final ClientSettings clientSettings = (ClientSettings) packet;
+    if (packet instanceof ClientSettingsPacket) {
+      final ClientSettingsPacket clientSettings = (ClientSettingsPacket) packet;
 
       // Validate the locale using a regex to filter unwanted characters.
       checkFrame(validateClientLocale(user, clientSettings.getLocale()), "invalid locale");
@@ -193,14 +364,20 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
       if (state == State.CLIENT_SETTINGS) {
         state = State.PLUGIN_MESSAGE;
       }
+
+      // Make sure we mark the ClientSettings as valid
+      resolvedClientSettings = true;
     }
 
-    if (packet instanceof PluginMessage) {
-      final PluginMessage pluginMessage = (PluginMessage) packet;
+    if (packet instanceof PluginMessagePacket) {
+      final PluginMessagePacket pluginMessage = (PluginMessagePacket) packet;
 
-      // Only the brand channel is important
+      // Only the brand channel is important, drop the rest
       if (pluginMessage.getChannel().equals("MC|Brand")
         || pluginMessage.getChannel().equals("minecraft:brand")) {
+        // Check if the brand packet was sent twice,
+        // which is not possible when using a vanilla Minecraft client.
+        checkFrame(!resolvedClientBrand, "duplicate client brand packet");
 
         // Check if the channel is correct - 1.13 uses the new namespace
         // system ('minecraft:' + channel) and anything below 1.13 uses
@@ -209,174 +386,268 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
         checkFrame(pluginMessage.getChannel().equals("MC|Brand") || v1_13, "invalid channel");
 
         // Validate the client branding using a regex to filter unwanted characters.
-        checkFrame(validateClientBrand(user, pluginMessage.content()), "invalid client brand");
+        if (Sonar.get().getConfig().getVerification().getBrand().isEnabled()) {
+          checkFrame(validateClientBrand(user, pluginMessage.content()), "invalid client brand");
+        }
 
         // Clients sometimes mess up the ClientSettings or PluginMessage packet.
         if (state == State.PLUGIN_MESSAGE) {
           // Send the transaction packet
           sendTransaction();
         }
+
+        // Make sure we mark the PluginMessage as valid
+        resolvedClientBrand = true;
       }
     }
 
-    if (packet instanceof Transaction) {
+    if (packet instanceof TransactionPacket) {
       // Check if we are currently expecting a Transaction packet
       assertState(State.TRANSACTION);
 
-      final Transaction transaction = (Transaction) packet;
+      final TransactionPacket transaction = (TransactionPacket) packet;
 
       // The transaction should always be accepted
       checkFrame(transaction.isAccepted(), "transaction not accepted?!");
       // Check if the transaction ID is valid
-      checkFrame(transaction.getId() == transactionId, "invalid transaction id");
+      checkFrame(transaction.getId() == expectedTransactionId, "invalid transaction id");
 
-      // Checking gravity is disabled, just finish verification
-      if (!Sonar.get().getConfig().isCheckGravity()) {
-        finish();
-        return;
-      }
-
-      // Make sure the player is unable to fly (the player is in spectator mode)
-      user.write(DEFAULT_ABILITIES);
-      // Teleport the player to the spawn position
-      user.write(SPAWN_TELEPORT);
+      // First, send an Abilities packet to the client to make
+      // sure the player falls even in spectator mode.
+      // Then, teleport the player to the spawn position.
+      sendAbilitiesAndTeleport();
 
       // 1.7-1.8 clients do not have a TeleportConfirm packet
       if (user.getProtocolVersion().compareTo(MINECRAFT_1_8) <= 0) {
-        // Immediately send the chunk data as 1.7-1.8 can't confirm teleports
+        // Immediately send the chunk data as 1.7-1.8 can't confirm teleport packets
         sendChunkData();
       } else {
-        // Set the state to TELEPORT to avoid false positives
-        // and go on with the flow of the verification.
-        state = State.TELEPORT;
+        // Send all previously sent packets in one flush since we didn't flush
+        // the channel earlier when we teleported the player.
+        user.getChannel().flush();
       }
     }
 
-    if (packet instanceof TeleportConfirm) {
+    if (packet instanceof TeleportConfirmPacket) {
       // Check if we are currently expecting a TeleportConfirm packet
       assertState(State.TELEPORT);
 
-      final TeleportConfirm teleportConfirm = (TeleportConfirm) packet;
+      // Check if the teleport ID is correct
+      final TeleportConfirmPacket teleportConfirm = (TeleportConfirmPacket) packet;
+      checkFrame(teleportConfirm.getTeleportId() == expectedTeleportId, "invalid teleport ID");
 
-      // Check if the teleport id is correct
-      final boolean teleportIdCorrect = teleportConfirm.getTeleportId() == SPAWN_TELEPORT.getTeleportId();
-      checkFrame(teleportIdCorrect, "invalid teleport ID");
+      // Reset all values to ensure safety on teleport
+      tick = 1;
+      posY = lastY = -1;
+      expectedTeleportId = -1;
 
       // Now we can send the chunk data
       sendChunkData();
     }
 
-    // Only handle positions if the player can send position packets.
-    if (state.canMove) {
-      if (packet instanceof Position) {
-        final Position position = (Position) packet;
-
-        // Immediately handle new position update
+    if (state != State.LOGIN_ACK) {
+      if (packet instanceof PlayerPositionPacket) {
+        final PlayerPositionPacket position = (PlayerPositionPacket) packet;
         handlePositionUpdate(position.getX(), position.getY(), position.getZ(), position.isOnGround());
       }
 
-      if (packet instanceof PositionLook) {
-        final PositionLook position = (PositionLook) packet;
-
-        // Immediately handle new position update
+      if (packet instanceof PlayerPositionLookPacket) {
+        final PlayerPositionLookPacket position = (PlayerPositionLookPacket) packet;
         handlePositionUpdate(position.getX(), position.getY(), position.getZ(), position.isOnGround());
       }
 
-      if (packet instanceof Player) {
-        final Player player = (Player) packet;
-
-        // This packet does not send new position data, reuse the last Y
-        handlePositionUpdate(lastX, lastY, lastZ, player.isOnGround());
+      if (packet instanceof PlayerTickPacket) {
+        final PlayerTickPacket player = (PlayerTickPacket) packet;
+        handlePositionUpdate(posX, posY, posZ, player.isOnGround());
       }
     }
   }
 
   private void handlePositionUpdate(final double x, final double y, final double z, final boolean ground) {
-    final double deltaY = lastY - y;
+    // 1.8 does not have a TeleportConfirm packet, so we need to handle the spawning differently
+    if (user.getProtocolVersion().compareTo(MINECRAFT_1_8) <= 0
+      && expectedTeleportId != -1 // Check if the teleport ID is currently unset
+      // Then, check if the position is equal to the spawn position
+      && x == SPAWN_X_POSITION && y == spawnYPosition && z == SPAWN_Z_POSITION) {
+      // Reset all values to ensure safety on teleport
+      tick = 1;
+      posY = -1;
+      expectedTeleportId = -1;
+    }
 
-    lastX = x;
-    lastY = y;
-    lastZ = z;
+    posX = x;
+    lastY = posY;
+    posY = y;
+    posZ = z;
 
     // The player is not allowed to move away from the collision platform.
     // This should not happen unless the max movement tick is configured to a high number.
-    checkFrame(Math.abs(x - BLOCKS_PER_ROW) <= BLOCKS_PER_ROW, "moved too far (x)");
-    checkFrame(Math.abs(z - BLOCKS_PER_ROW) <= BLOCKS_PER_ROW, "moved too far (z)");
+    checkFrame(Math.abs(x - BLOCKS_PER_ROW) < BLOCKS_PER_ROW, "moved too far (x)");
+    checkFrame(Math.abs(z - BLOCKS_PER_ROW) < BLOCKS_PER_ROW, "moved too far (z)");
 
-    // The onGround property can never be true when we aren't checking for collisions
-    checkFrame(!ground || state == State.COLLISIONS, "invalid ground state");
-
-    // Check if the chunk might be unloaded
-    if (deltaY > 0.07) {
-      // Verify the player if they sent correct movement packets
-      if (movementTick++ >= MAX_MOVEMENT_TICK) {
-        if (Sonar.get().getConfig().isCheckCollisions()) {
-          if (state != State.COLLISIONS) {
-            // Set the state to COLLISIONS to avoid false positives
-            // and go on with the flow of the verification.
-            // Now we don't care about gravity anymore,
-            // we just want the player to collide with the blocks.
-            state = State.COLLISIONS;
-          } else {
-            // Calculate the difference between the player's Y coordinate and the expected Y coordinate
-            final double offsetY = DEFAULT_Y_COLLIDE_POSITION - y;
-
-            // The offset cannot greater than 0 since the blocks will not let the player fall through them.
-            checkFrame(offsetY <= 0, "no collisions: " + offsetY);
-
-            // Check if the player is colliding by performing a basic Y offset check.
-            if (ground) {
-              // The player is colliding, finish verification
-              // TODO: Check for: velocity, entities/mounting, interactions
-              finish();
-            }
-          }
-        } else {
-          // Checking collisions is disabled, just finish verification
-          finish();
-        }
-      } else if (y <= DYNAMIC_SPAWN_Y_POSITION && y >= DEFAULT_Y_COLLIDE_POSITION) {
-        // This is a basic gravity check that predicts the next y position
-        final double predictedY = PREPARED_MOVEMENT_PACKETS[movementTick];
-        final double offsetY = Math.abs(deltaY - predictedY);
-
-        // Check if the y motion is roughly equal to the predicted value
-        final String verbose = String.format("%d: %.7f %.10f %.10f!%.10f", movementTick, y, offsetY, deltaY, predictedY);
-        checkFrame(offsetY < 0.01, verbose);
+    // Check if the client hasn't moved before sending the first movement packet
+    if (!listenForMovements) {
+      if (posX == SPAWN_X_POSITION && posZ == SPAWN_Z_POSITION) {
+        // Now, once we verified the X and Z position, we can safely check for gravity
+        listenForMovements = true;
       }
+
+      lastY = spawnYPosition;
+      return;
+    }
+
+    final double deltaY = lastY - y;
+    // The deltaY is 0 whenever the player sends their first position packet.
+    // We have to account for this or the player will fail the verification.
+    if (deltaY == 0) {
+      // Check for too many ignored Y ticks
+      final int maxIgnoredTicks = Sonar.get().getConfig().getVerification().getGravity().getMaxIgnoredTicks();
+      checkFrame(++ignoredMovementTicks < maxIgnoredTicks, "too many ignored ticks");
+      return;
+    }
+
+    // Calculate the difference between the player's Y coordinate and the expected Y coordinate
+    double collisionOffsetY = (DEFAULT_Y_COLLIDE_POSITION + blockType.getBlockHeight()) - y;
+    if (user.getProtocolVersion().compareTo(MINECRAFT_1_8) < 0) {
+      collisionOffsetY += 1.62f; // 1.7 is weird and sends the head position instead of the AABB minY
+    }
+
+    // Check if the player is colliding by performing a basic Y offset check.
+    // The offset cannot be greater than 0 since the blocks will not let the player fall through them.
+    checkFrame(collisionOffsetY <= 0, "fell through blocks: " + collisionOffsetY);
+
+    if (tick > maxMovementTick) {
+      // Log/debug position if enabled in the configuration
+      if (Sonar.get().getConfig().getVerification().isDebugXYZPositions()) {
+        FALLBACK.getLogger().info("{}: {}/{}/{} - deltaY: {} - ground: {} - collision: {}",
+          username, x, y, z, deltaY, ground, collisionOffsetY);
+      }
+
+      // If the collision check is disabled, finish verification
+      if (!Sonar.get().getConfig().getVerification().getGravity().isCheckCollisions()) {
+        captchaOrFinish();
+        return;
+      }
+
+      // Perform the collision check
+      if (ground) {
+        // Make sure the player is actually colliding with the blocks and not only spoofing ground
+        checkFrame(collisionOffsetY > -0.03, "illegal collision: " + collisionOffsetY);
+        // The player is colliding to blocks, finish verification
+        captchaOrFinish();
+        return;
+      } else {
+        // Make sure the player is colliding with blocks but is sending an invalid ground state
+        checkFrame(collisionOffsetY != 0, "no ground: " + collisionOffsetY);
+      }
+    } else {
+      // Check if the player is spoofing the ground state
+      checkFrame(!ground, "spoofed ground state");
+    }
+
+    // Make sure we don't run out of predicted Y motions
+    checkFrame(tick < preparedCachedYMotions.length, "too many movements");
+
+    if (!ground) {
+      final double predictedY = preparedCachedYMotions[tick];
+      final double offsetY = Math.abs(deltaY - predictedY);
+
+      // Log/debug position if enabled in the configuration
+      if (Sonar.get().getConfig().getVerification().isDebugXYZPositions()) {
+        FALLBACK.getLogger().info("{}: {}/{}/{} - deltaY: {} - prediction: {} - offset: {}",
+          username, x, y, z, deltaY, predictedY, offsetY);
+      }
+
+      // Check if the y motion is roughly equal to the predicted value
+      checkFrame(offsetY < 0.005, String.format("invalid gravity: %d, %.7f, %.10f, %.10f != %.10f",
+        tick, y, offsetY, deltaY, predictedY));
+    }
+    tick++;
+  }
+
+  private void captchaOrFinish() {
+    if (FALLBACK.shouldDoMapCaptcha()) {
+      if (MapInfoPreparer.getPreparedCAPTCHAs() == 0) {
+        // This should not happen, but we have to return if there is no captcha prepared
+        user.disconnect(Sonar.get().getConfig().getVerification().getCurrentlyPreparing());
+        return;
+      }
+      // Set the state to MAP_CAPTCHA, so we don't handle any unnecessary packets
+      state = State.MAP_CAPTCHA;
+      if (!Sonar.get().getConfig().getVerification().getGravity().isEnabled()
+        && user.getProtocolVersion().compareTo(MINECRAFT_1_18_2) >= 0) {
+        // Make sure the player escapes the 1.18.2+ "Loading terrain" screen
+        user.delayedWrite(CAPTCHA_SPAWN_POSITION);
+      }
+      // Initialize the map captcha
+      handleMapCaptcha();
+    } else {
+      // Finish the verification
+      finish();
     }
   }
 
+  private void handleMapCaptcha() {
+    // Reset max tries
+    captchaTriesLeft = Sonar.get().getConfig().getVerification().getMap().getMaxTries();
+
+    // Set slot to map
+    user.delayedWrite(new SetSlotPacket(0, 36, 1, 0,
+      ItemMapType.FILLED_MAP.getId(user.getProtocolVersion()), SetSlotPacket.MAP_NBT));
+    // Send random captcha to the player
+    captcha = MapInfoPreparer.getRandomCaptcha();
+    Objects.requireNonNull(captcha).write(user);
+    // Teleport the player to the position above the platform
+    user.delayedWrite(CAPTCHA_POSITION);
+    // Make sure the player cannot move
+    user.delayedWrite(CAPTCHA_ABILITIES);
+    // Make sure the player knows what to do
+    user.delayedWrite(enterCodeMessage);
+    // Send all packets in one flush
+    user.getChannel().flush();
+  }
+
+  private void finish() {
+    state = State.SUCCESS;
+
+    // Increment amount of total successful verifications
+    GlobalSonarStatistics.totalSuccessfulVerifications++;
+
+    // Add verified player to the database
+    final VerifiedPlayer verifiedPlayer = new VerifiedPlayer(user.getInetAddress().toString(), playerUuid,
+      login.getStart());
+    Sonar.get().getVerifiedPlayerController().add(verifiedPlayer);
+
+    // Call the VerifySuccessEvent for external API usage
+    Sonar.get().getEventManager().publish(new UserVerifySuccessEvent(username, playerUuid, user, login.delay()));
+
+    // Disconnect player with the verification success message
+    user.disconnect(Sonar.get().getConfig().getVerification().getVerificationSuccess());
+
+    FALLBACK.getLogger().info(Sonar.get().getConfig().getVerification().getSuccessLog()
+      .replace("%name%", username)
+      .replace("%time%", login.toString()));
+  }
+
+  /**
+   * Fails the verification if a certain state is unexpected.
+   *
+   * @param expectedState Expected state
+   */
   private void assertState(final @NotNull State expectedState) {
-    if (expectedState != state) {
-      user.fail("expected " + expectedState + ", got " + state);
-    }
+    checkFrame(state == expectedState, "expected " + expectedState + ", got " + state);
   }
 
+  /**
+   * Checks if a certain condition is met, fails the verification if not.
+   *
+   * @param condition Condition to fail if it's false
+   * @param message   Messages displayed in the stacktrace
+   */
   private void checkFrame(final boolean condition, final String message) {
     if (!condition) {
       user.fail(message);
       throw new CorruptedFrameException(message);
     }
   }
-
-  private void finish() {
-    state = State.SUCCESS;
-
-    user.getFallback().getConnected().remove(username);
-
-    // Add verified player to the database
-    final VerifiedPlayer verifiedPlayer = new VerifiedPlayer(user.getInetAddress().toString(), uuid, login.getStart());
-    Sonar.get().getVerifiedPlayerController().add(verifiedPlayer);
-
-    // Call the VerifySuccessEvent for external API usage
-    Sonar.get().getEventManager().publish(new UserVerifySuccessEvent(username, uuid, user, login.delay()));
-
-    // Disconnect player with the verification success message
-    user.disconnect(Sonar.get().getConfig().getVerificationSuccess());
-
-    user.getFallback().getLogger().info(Sonar.get().getConfig().getVerificationSuccessfulLog()
-      .replace("%name%", username)
-      .replace("%time%", login.toString()));
-  }
 }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPacket.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPacketDecoder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,25 +21,29 @@ import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
 import io.netty.handler.codec.CorruptedFrameException;
-import lombok.RequiredArgsConstructor;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 
+import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT_1_20_2;
+import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.Direction.SERVERBOUND;
+import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.GAME;
+import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.LOGIN;
 import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.readVarInt;
 
-@RequiredArgsConstructor
 public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
-  private final FallbackUser<?, ?> user;
-  private final FallbackPacketRegistry.ProtocolRegistry registry;
+  private final FallbackUser user;
   private final FallbackPacketListener listener;
+  private FallbackPacketRegistry.ProtocolRegistry registry;
 
-  public FallbackPacketDecoder(final @NotNull FallbackUser<?, ?> user,
+  public FallbackPacketDecoder(final @NotNull FallbackUser user,
                                final @NotNull FallbackPacketListener listener) {
     this.user = user;
-    this.registry = FallbackPacketRegistry.SONAR.getProtocolRegistry(
-      FallbackPacketRegistry.Direction.SERVERBOUND, user.getProtocolVersion()
-    );
     this.listener = listener;
+    updateRegistry(user.getProtocolVersion().compareTo(MINECRAFT_1_20_2) >= 0 ? LOGIN : GAME);
+  }
+
+  public void updateRegistry(final @NotNull FallbackPacketRegistry registry) {
+    this.registry = registry.getProtocolRegistry(SERVERBOUND, user.getProtocolVersion());
   }
 
   @Override
@@ -48,38 +52,56 @@ public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
     if (msg instanceof ByteBuf) {
       final ByteBuf byteBuf = (ByteBuf) msg;
 
+      // Release the ByteBuf if the connection is not active
+      // or the ByteBuf doesn't contain any data to avoid
+      // memory leaks or other potential exploits.
       if (!ctx.channel().isActive() || !byteBuf.isReadable()) {
         byteBuf.release();
         return;
       }
 
       final int originalReaderIndex = byteBuf.readerIndex();
+      // Read the packet ID and then create the packet from it
       final int packetId = readVarInt(byteBuf);
       final FallbackPacket packet = registry.createPacket(packetId);
 
+      // If the packet isn't found, skip it
       if (packet == null) {
         byteBuf.readerIndex(originalReaderIndex);
-      } else {
-        try {
-          doLengthSanityChecks(byteBuf, packet);
-
-          try {
-            packet.decode(byteBuf, user.getProtocolVersion());
-          } catch (Throwable throwable) {
-            user.fail("could not decode packet");
-            throw new CorruptedFrameException("Failed to decode packet");
-          }
-
-          if (byteBuf.isReadable()) {
-            user.fail("could not read packet to end (" + byteBuf.readableBytes() + " bytes left)");
-            throw new CorruptedFrameException("Could not read packet to end");
-          }
-
-          listener.handle(packet);
-        } finally {
-          byteBuf.release();
-        }
+        return;
       }
+
+      try {
+        // Ensure that the packet isn't too large or too small
+        doLengthSanityChecks(byteBuf, packet);
+
+        try {
+          // Try to decode the packet for the given protocol version
+          packet.decode(byteBuf, user.getProtocolVersion());
+        } catch (Throwable throwable) {
+          user.fail("failed to decode packet (" + byteBuf.readableBytes() + " bytes)");
+          throw new CorruptedFrameException("Failed to decode packet");
+        }
+
+        // Check if the packet still has bytes left after we decoded it
+        if (byteBuf.isReadable()) {
+          user.fail("could not read packet to end (" + byteBuf.readableBytes() + " bytes left)");
+          throw new CorruptedFrameException("Could not read packet to end");
+        }
+
+        // Let our verification handler process the packet
+        listener.handle(packet);
+
+        // Fire channel read to avoid timeout
+        ctx.fireChannelRead(packet);
+      } finally {
+        // Release the ByteBuf to avoid memory leaks
+        byteBuf.release();
+      }
+    } else {
+      // Packets are always ByteBufs - if we detect an unknown object, fail verification
+      user.fail("packet is not a ByteBuf");
+      throw new CorruptedFrameException("Packet is not a ByteBuf?!");
     }
   }
 
@@ -87,13 +109,13 @@ public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
                                     final @NotNull FallbackPacket packet) throws Exception {
     final int expectedMaxLen = packet.expectedMaxLength(byteBuf, user.getProtocolVersion());
     if (expectedMaxLen != -1 && byteBuf.readableBytes() > expectedMaxLen) {
-      user.fail("packet too large");
+      user.fail("packet too large (" + byteBuf.readableBytes() + " bytes)");
       throw new CorruptedFrameException("Packet too large");
     }
 
     final int expectedMinLen = packet.expectedMinLength(byteBuf, user.getProtocolVersion());
     if (byteBuf.readableBytes() < expectedMinLen) {
-      user.fail("packet too small");
+      user.fail("packet too small (" + byteBuf.readableBytes() + " bytes)");
       throw new CorruptedFrameException("Packet too small");
     }
   }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPacketEncoder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,19 +20,24 @@ package xyz.jonesdev.sonar.common.fallback.protocol;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.MessageToByteEncoder;
+import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 
+import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.Direction.CLIENTBOUND;
+import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.LOGIN;
 import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.writeVarInt;
 
 public final class FallbackPacketEncoder extends MessageToByteEncoder<FallbackPacket> {
   private final ProtocolVersion protocolVersion;
-  private final FallbackPacketRegistry.ProtocolRegistry registry;
+  private FallbackPacketRegistry.ProtocolRegistry registry;
 
   public FallbackPacketEncoder(final ProtocolVersion protocolVersion) {
     this.protocolVersion = protocolVersion;
-    this.registry = FallbackPacketRegistry.SONAR.getProtocolRegistry(
-      FallbackPacketRegistry.Direction.CLIENTBOUND, protocolVersion
-    );
+    updateRegistry(LOGIN);
+  }
+
+  public void updateRegistry(final @NotNull FallbackPacketRegistry registry) {
+    this.registry = registry.getProtocolRegistry(CLIENTBOUND, protocolVersion);
   }
 
   @Override

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPacketListener.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPacketRegistry.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,7 +22,11 @@ import io.netty.util.collection.IntObjectMap;
 import lombok.Data;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
-import xyz.jonesdev.sonar.common.fallback.protocol.packets.*;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.FinishConfigurationPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.RegistryDataPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginAcknowledgedPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginSuccessPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;
 
 import java.util.*;
 import java.util.function.Supplier;
@@ -32,17 +36,42 @@ import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.*;
 // Most of this is taken from
 // https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/StateRegistry.java
 public enum FallbackPacketRegistry {
-  SONAR {
+  LOGIN {
     {
-      clientbound.fallback = false;
-      serverbound.fallback = false;
+      serverbound.register(LoginAcknowledgedPacket.class, LoginAcknowledgedPacket::new,
+        map(0x03, MINECRAFT_1_20_2, false));
 
-      // LOGIN
-      clientbound.register(ServerLoginSuccess.class, ServerLoginSuccess::new,
+      clientbound.register(LoginSuccessPacket.class, LoginSuccessPacket::new,
         map(0x02, MINECRAFT_1_7_2, false));
 
-      // GAME
-      clientbound.register(JoinGame.class, JoinGame::new,
+      clientbound.register(DisconnectPacket.class, DisconnectPacket::new,
+        map(0x00, MINECRAFT_1_7_2, true));
+    }
+  },
+  CONFIG {
+    {
+      clientbound.register(DisconnectPacket.class, DisconnectPacket::new,
+        map(0x01, MINECRAFT_1_20_2, true));
+      clientbound.register(FinishConfigurationPacket.class, FinishConfigurationPacket::new,
+        map(0x02, MINECRAFT_1_20_2, false));
+      clientbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
+        map(0x03, MINECRAFT_1_20_2, false));
+      clientbound.register(RegistryDataPacket.class, RegistryDataPacket::new,
+        map(0x05, MINECRAFT_1_20_2, true));
+
+      serverbound.register(ClientSettingsPacket.class, ClientSettingsPacket::new,
+        map(0x00, MINECRAFT_1_20_2, false));
+      serverbound.register(PluginMessagePacket.class, PluginMessagePacket::new,
+        map(0x01, MINECRAFT_1_20_2, false));
+      serverbound.register(FinishConfigurationPacket.class, FinishConfigurationPacket::new,
+        map(0x02, MINECRAFT_1_20_2, false));
+      serverbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
+        map(0x03, MINECRAFT_1_20_2, false));
+    }
+  },
+  GAME {
+    {
+      clientbound.register(JoinGamePacket.class, JoinGamePacket::new,
         map(0x01, MINECRAFT_1_7_2, true),
         map(0x23, MINECRAFT_1_9, true),
         map(0x25, MINECRAFT_1_13, true),
@@ -54,8 +83,9 @@ public enum FallbackPacketRegistry {
         map(0x23, MINECRAFT_1_19, true),
         map(0x25, MINECRAFT_1_19_1, true),
         map(0x24, MINECRAFT_1_19_3, true),
-        map(0x28, MINECRAFT_1_19_4, true));
-      clientbound.register(KeepAlive.class, KeepAlive::new,
+        map(0x28, MINECRAFT_1_19_4, true),
+        map(0x29, MINECRAFT_1_20_2, true));
+      clientbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
         map(0x00, MINECRAFT_1_7_2, false),
         map(0x1F, MINECRAFT_1_9, false),
         map(0x21, MINECRAFT_1_13, false),
@@ -67,8 +97,9 @@ public enum FallbackPacketRegistry {
         map(0x1E, MINECRAFT_1_19, false),
         map(0x20, MINECRAFT_1_19_1, false),
         map(0x1F, MINECRAFT_1_19_3, false),
-        map(0x23, MINECRAFT_1_19_4, false));
-      clientbound.register(Disconnect.class, Disconnect::new,
+        map(0x23, MINECRAFT_1_19_4, false),
+        map(0x24, MINECRAFT_1_20_2, false));
+      clientbound.register(DisconnectPacket.class, DisconnectPacket::new,
         map(0x40, MINECRAFT_1_7_2, true),
         map(0x1A, MINECRAFT_1_9, true),
         map(0x1B, MINECRAFT_1_13, true),
@@ -80,8 +111,9 @@ public enum FallbackPacketRegistry {
         map(0x17, MINECRAFT_1_19, true),
         map(0x19, MINECRAFT_1_19_1, true),
         map(0x17, MINECRAFT_1_19_3, true),
-        map(0x1A, MINECRAFT_1_19_4, true));
-      clientbound.register(PositionLook.class, PositionLook::new,
+        map(0x1A, MINECRAFT_1_19_4, true),
+        map(0x1B, MINECRAFT_1_20_2, true));
+      clientbound.register(PlayerPositionLookPacket.class, PlayerPositionLookPacket::new,
         map(0x08, MINECRAFT_1_7_2, true),
         map(0x2E, MINECRAFT_1_9, true),
         map(0x2F, MINECRAFT_1_12_1, true),
@@ -94,8 +126,9 @@ public enum FallbackPacketRegistry {
         map(0x36, MINECRAFT_1_19, true),
         map(0x39, MINECRAFT_1_19_1, true),
         map(0x38, MINECRAFT_1_19_3, true),
-        map(0x3C, MINECRAFT_1_19_4, true));
-      clientbound.register(Abilities.class, Abilities::new,
+        map(0x3C, MINECRAFT_1_19_4, true),
+        map(0x3E, MINECRAFT_1_20_2, true));
+      clientbound.register(ClientAbilitiesPacket.class, ClientAbilitiesPacket::new,
         map(0x39, MINECRAFT_1_7_2, true),
         map(0x2B, MINECRAFT_1_9, true),
         map(0x2C, MINECRAFT_1_12_1, true),
@@ -108,8 +141,9 @@ public enum FallbackPacketRegistry {
         map(0x2f, MINECRAFT_1_19, true),
         map(0x31, MINECRAFT_1_19_1, true),
         map(0x30, MINECRAFT_1_19_3, true),
-        map(0x34, MINECRAFT_1_19_4, true));
-      clientbound.register(EmptyChunkData.class, EmptyChunkData::new,
+        map(0x34, MINECRAFT_1_19_4, true),
+        map(0x36, MINECRAFT_1_20_2, true));
+      clientbound.register(ChunkDataPacket.class, ChunkDataPacket::new,
         map(0x21, MINECRAFT_1_7_2, true),
         map(0x20, MINECRAFT_1_9, true),
         map(0x22, MINECRAFT_1_13, true),
@@ -121,20 +155,36 @@ public enum FallbackPacketRegistry {
         map(0x1F, MINECRAFT_1_19, true),
         map(0x21, MINECRAFT_1_19_1, true),
         map(0x20, MINECRAFT_1_19_3, true),
-        map(0x24, MINECRAFT_1_19_4, true));
-      clientbound.register(UpdateSectionBlocks.class, UpdateSectionBlocks::new,
+        map(0x24, MINECRAFT_1_19_4, true),
+        map(0x25, MINECRAFT_1_20_2, true));
+      clientbound.register(UpdateSectionBlocksPacket.class, UpdateSectionBlocksPacket::new,
         map(0x22, MINECRAFT_1_7_2, true),
-        map(16, MINECRAFT_1_9, true),
-        map(15, MINECRAFT_1_13, true),
-        map(16, MINECRAFT_1_15, true),
-        map(15, MINECRAFT_1_16, true),
-        map(59, MINECRAFT_1_16_2, true),
-        map(63, MINECRAFT_1_17, true),
-        map(61, MINECRAFT_1_19, true),
-        map(64, MINECRAFT_1_19_1, true),
-        map(63, MINECRAFT_1_19_3, true),
-        map(67, MINECRAFT_1_19_4, true));
-      clientbound.register(DefaultSpawnPosition.class, DefaultSpawnPosition::new,
+        map(0x10, MINECRAFT_1_9, true),
+        map(0x0F, MINECRAFT_1_13, true),
+        map(0x10, MINECRAFT_1_15, true),
+        map(0x0F, MINECRAFT_1_16, true),
+        map(0x3B, MINECRAFT_1_16_2, true),
+        map(0x3F, MINECRAFT_1_17, true),
+        map(0x3D, MINECRAFT_1_19, true),
+        map(0x40, MINECRAFT_1_19_1, true),
+        map(0x3F, MINECRAFT_1_19_3, true),
+        map(0x43, MINECRAFT_1_19_4, true),
+        map(0x45, MINECRAFT_1_20_2, true),
+        map(0x47, MINECRAFT_1_20_3, true));
+      clientbound.register(TransactionPacket.class, TransactionPacket::new,
+        map(0x32, MINECRAFT_1_7_2, true),
+        map(0x11, MINECRAFT_1_9, true),
+        map(0x12, MINECRAFT_1_13, true),
+        map(0x13, MINECRAFT_1_15, true),
+        map(0x12, MINECRAFT_1_16, true),
+        map(0x11, MINECRAFT_1_16_2, true),
+        map(0x30, MINECRAFT_1_17, true),
+        map(0x2D, MINECRAFT_1_19, true),
+        map(0x2F, MINECRAFT_1_19_1, true),
+        map(0x2E, MINECRAFT_1_19_3, true),
+        map(0x32, MINECRAFT_1_19_4, true),
+        map(0x33, MINECRAFT_1_20_2, true));
+      clientbound.register(DefaultSpawnPositionPacket.class, DefaultSpawnPositionPacket::new,
         map(0x05, MINECRAFT_1_7_2, true),
         map(0x43, MINECRAFT_1_9, true),
         map(0x45, MINECRAFT_1_12, true),
@@ -147,21 +197,61 @@ public enum FallbackPacketRegistry {
         map(0x4A, MINECRAFT_1_19, true),
         map(0x4D, MINECRAFT_1_19_1, true),
         map(0x4C, MINECRAFT_1_19_3, true),
-        map(0x50, MINECRAFT_1_19_4, true));
-      clientbound.register(Transaction.class, Transaction::new,
-        map(0x32, MINECRAFT_1_7_2, true),
-        map(0x11, MINECRAFT_1_9, true),
-        map(0x12, MINECRAFT_1_13, true),
-        map(0x13, MINECRAFT_1_15, true),
-        map(0x12, MINECRAFT_1_16, true),
-        map(0x11, MINECRAFT_1_16_2, true),
-        map(0x30, MINECRAFT_1_17, true),
-        map(0x2D, MINECRAFT_1_19, true),
-        map(0x2F, MINECRAFT_1_19_1, true),
-        map(0x2E, MINECRAFT_1_19_3, true),
-        map(0x32, MINECRAFT_1_19_4, true));
+        map(0x50, MINECRAFT_1_19_4, true),
+        map(0x52, MINECRAFT_1_20_2, true),
+        map(0x54, MINECRAFT_1_20_3, true));
+      clientbound.register(MapDataPacket.class, MapDataPacket::new,
+        map(0x34, MINECRAFT_1_7_2, true),
+        map(0x24, MINECRAFT_1_9, true),
+        map(0x26, MINECRAFT_1_13, true),
+        map(0x27, MINECRAFT_1_15, true),
+        map(0x26, MINECRAFT_1_16, true),
+        map(0x25, MINECRAFT_1_16_2, true),
+        map(0x27, MINECRAFT_1_17, true),
+        map(0x24, MINECRAFT_1_19, true),
+        map(0x26, MINECRAFT_1_19_1, true),
+        map(0x25, MINECRAFT_1_19_3, true),
+        map(0x29, MINECRAFT_1_19_4, true),
+        map(0x2A, MINECRAFT_1_20_2, true));
+      clientbound.register(SetSlotPacket.class, SetSlotPacket::new,
+        map(0x2F, MINECRAFT_1_7_2, true),
+        map(0x16, MINECRAFT_1_9, true),
+        map(0x17, MINECRAFT_1_13, true),
+        map(0x16, MINECRAFT_1_14, true),
+        map(0x17, MINECRAFT_1_15, true),
+        map(0x16, MINECRAFT_1_16, true),
+        map(0x15, MINECRAFT_1_16_2, true),
+        map(0x16, MINECRAFT_1_17, true),
+        map(0x13, MINECRAFT_1_19, true),
+        map(0x12, MINECRAFT_1_19_3, true),
+        map(0x14, MINECRAFT_1_19_4, true),
+        map(0x15, MINECRAFT_1_20_2, true));
+      clientbound.register(UniversalChatPacket.class, UniversalChatPacket::new,
+        map(0x02, MINECRAFT_1_7_2, false),
+        map(0x0F, MINECRAFT_1_9, false),
+        map(0x0E, MINECRAFT_1_13, false),
+        map(0x0F, MINECRAFT_1_15, false),
+        map(0x0E, MINECRAFT_1_16, false),
+        map(0x0F, MINECRAFT_1_17, false),
+        map(0x5F, MINECRAFT_1_19, false),
+        map(0x62, MINECRAFT_1_19_1, false),
+        map(0x60, MINECRAFT_1_19_3, false),
+        map(0x64, MINECRAFT_1_19_4, false),
+        map(0x67, MINECRAFT_1_20_2, false),
+        map(0x69, MINECRAFT_1_20_3, false));
+      clientbound.register(GameEventPacket.class, GameEventPacket::new,
+        map(0x20, MINECRAFT_1_20_3, true));
 
-      serverbound.register(KeepAlive.class, KeepAlive::new,
+      serverbound.register(UniversalChatPacket.class, UniversalChatPacket::new,
+        map(0x01, MINECRAFT_1_7_2, false),
+        map(0x02, MINECRAFT_1_9, false),
+        map(0x03, MINECRAFT_1_12, false),
+        map(0x02, MINECRAFT_1_12_1, false),
+        map(0x03, MINECRAFT_1_14, false),
+        map(0x04, MINECRAFT_1_19, false),
+        map(0x05, MINECRAFT_1_19_1, false),
+        map(0x05, MINECRAFT_1_19_3, false));
+      serverbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
         map(0x00, MINECRAFT_1_7_2, false),
         map(0x0B, MINECRAFT_1_9, false),
         map(0x0C, MINECRAFT_1_12, false),
@@ -173,8 +263,10 @@ public enum FallbackPacketRegistry {
         map(0x11, MINECRAFT_1_19, false),
         map(0x12, MINECRAFT_1_19_1, false),
         map(0x11, MINECRAFT_1_19_3, false),
-        map(0x12, MINECRAFT_1_19_4, false));
-      serverbound.register(ClientSettings.class, ClientSettings::new,
+        map(0x12, MINECRAFT_1_19_4, false),
+        map(0x14, MINECRAFT_1_20_2, false),
+        map(0x15, MINECRAFT_1_20_3, false));
+      serverbound.register(ClientSettingsPacket.class, ClientSettingsPacket::new,
         map(0x15, MINECRAFT_1_7_2, false),
         map(0x04, MINECRAFT_1_9, false),
         map(0x05, MINECRAFT_1_12, false),
@@ -183,8 +275,9 @@ public enum FallbackPacketRegistry {
         map(0x07, MINECRAFT_1_19, false),
         map(0x08, MINECRAFT_1_19_1, false),
         map(0x07, MINECRAFT_1_19_3, false),
-        map(0x08, MINECRAFT_1_19_4, false));
-      serverbound.register(PluginMessage.class, PluginMessage::new,
+        map(0x08, MINECRAFT_1_19_4, false),
+        map(0x09, MINECRAFT_1_20_2, false));
+      serverbound.register(PluginMessagePacket.class, PluginMessagePacket::new,
         map(0x17, MINECRAFT_1_7_2, false),
         map(0x09, MINECRAFT_1_9, false),
         map(0x0A, MINECRAFT_1_12, false),
@@ -195,8 +288,9 @@ public enum FallbackPacketRegistry {
         map(0x0C, MINECRAFT_1_19, false),
         map(0x0D, MINECRAFT_1_19_1, false),
         map(0x0C, MINECRAFT_1_19_3, false),
-        map(0x0D, MINECRAFT_1_19_4, false));
-      serverbound.register(PositionLook.class, PositionLook::new,
+        map(0x0D, MINECRAFT_1_19_4, false),
+        map(0x0F, MINECRAFT_1_20_2, false));
+      serverbound.register(PlayerPositionLookPacket.class, PlayerPositionLookPacket::new,
         map(0x06, MINECRAFT_1_7_2, false),
         map(0x0D, MINECRAFT_1_9, false),
         map(0x0F, MINECRAFT_1_12, false),
@@ -208,10 +302,12 @@ public enum FallbackPacketRegistry {
         map(0x14, MINECRAFT_1_19, false),
         map(0x15, MINECRAFT_1_19_1, false),
         map(0x14, MINECRAFT_1_19_3, false),
-        map(0x15, MINECRAFT_1_19_4, false));
-      serverbound.register(TeleportConfirm.class, TeleportConfirm::new,
+        map(0x15, MINECRAFT_1_19_4, false),
+        map(0x17, MINECRAFT_1_20_2, false),
+        map(0x18, MINECRAFT_1_20_3, false));
+      serverbound.register(TeleportConfirmPacket.class, TeleportConfirmPacket::new,
         map(0x00, MINECRAFT_1_9, false));
-      serverbound.register(Position.class, Position::new,
+      serverbound.register(PlayerPositionPacket.class, PlayerPositionPacket::new,
         map(0x04, MINECRAFT_1_7_2, false),
         map(0x0C, MINECRAFT_1_9, false),
         map(0x0E, MINECRAFT_1_12, false),
@@ -223,8 +319,10 @@ public enum FallbackPacketRegistry {
         map(0x13, MINECRAFT_1_19, false),
         map(0x14, MINECRAFT_1_19_1, false),
         map(0x13, MINECRAFT_1_19_3, false),
-        map(0x14, MINECRAFT_1_19_4, false));
-      serverbound.register(Player.class, Player::new,
+        map(0x14, MINECRAFT_1_19_4, false),
+        map(0x16, MINECRAFT_1_20_2, false),
+        map(0x17, MINECRAFT_1_20_3, false));
+      serverbound.register(PlayerTickPacket.class, PlayerTickPacket::new,
         map(0x03, MINECRAFT_1_7_2, false),
         map(0x0F, MINECRAFT_1_9, false),
         map(0x0D, MINECRAFT_1_12, false),
@@ -236,8 +334,10 @@ public enum FallbackPacketRegistry {
         map(0x16, MINECRAFT_1_19, false),
         map(0x17, MINECRAFT_1_19_1, false),
         map(0x16, MINECRAFT_1_19_3, false),
-        map(0x17, MINECRAFT_1_19_4, false));
-      serverbound.register(Transaction.class, Transaction::new,
+        map(0x17, MINECRAFT_1_19_4, false),
+        map(0x19, MINECRAFT_1_20_2, false),
+        map(0x1A, MINECRAFT_1_20_3, false));
+      serverbound.register(TransactionPacket.class, TransactionPacket::new,
         map(0x0F, MINECRAFT_1_7_2, false),
         map(0x05, MINECRAFT_1_9, false),
         map(0x06, MINECRAFT_1_12, false),
@@ -248,7 +348,9 @@ public enum FallbackPacketRegistry {
         map(0x1F, MINECRAFT_1_19, false),
         map(0x20, MINECRAFT_1_19_1, false),
         map(0x1F, MINECRAFT_1_19_3, false),
-        map(0x20, MINECRAFT_1_19_4, false));
+        map(0x20, MINECRAFT_1_19_4, false),
+        map(0x23, MINECRAFT_1_20_2, false),
+        map(0x24, MINECRAFT_1_20_3, false));
     }
   };
 
@@ -267,25 +369,20 @@ public enum FallbackPacketRegistry {
 
   public static class PacketRegistry {
     private final Map<ProtocolVersion, ProtocolRegistry> versions;
-    private boolean fallback = true;
 
     PacketRegistry() {
-      Map<ProtocolVersion, ProtocolRegistry> mutableVersions = new EnumMap<>(ProtocolVersion.class);
-      for (ProtocolVersion version : ProtocolVersion.values()) {
-        if (!version.isLegacy() && !version.isUnknown()) {
+      final Map<ProtocolVersion, ProtocolRegistry> mutableVersions = new EnumMap<>(ProtocolVersion.class);
+      for (final ProtocolVersion version : ProtocolVersion.values()) {
+        if (!version.isUnknown()) {
           mutableVersions.put(version, new ProtocolRegistry(version));
         }
       }
-
-      versions = Collections.unmodifiableMap(mutableVersions);
+      this.versions = Collections.unmodifiableMap(mutableVersions);
     }
 
     ProtocolRegistry getProtocolRegistry(final ProtocolVersion version) {
       final ProtocolRegistry registry = versions.get(version);
       if (registry == null) {
-        if (fallback) {
-          return getProtocolRegistry(MINIMUM_VERSION);
-        }
         throw new IllegalArgumentException("Could not find data for protocol version " + version);
       }
       return registry;
@@ -310,7 +407,7 @@ public enum FallbackPacketRegistry {
             break;
           }
 
-          final ProtocolRegistry registry = this.versions.get(protocol);
+          final ProtocolRegistry registry = versions.get(protocol);
           if (registry == null) {
             throw new IllegalArgumentException("Unknown protocol version "
               + current.protocolVersion);
@@ -339,35 +436,12 @@ public enum FallbackPacketRegistry {
     private static ProtocolVersion getProtocolVersion(final @NotNull PacketMapping current,
                                                       final @NotNull PacketMapping next,
                                                       final @NotNull ProtocolVersion from) {
-      final ProtocolVersion lastValid = current.lastValidProtocolVersion;
-
-      if (lastValid != null) {
-        if (next != current) {
-          throw new IllegalArgumentException("Cannot add a mapping after last valid mapping");
-        }
-
-        if (from.compareTo(lastValid) > 0) {
-          throw new IllegalArgumentException(
-            "Last mapping version cannot be higher than highest mapping version");
-        }
-      }
-
-      final ProtocolVersion last = (ProtocolVersion) SUPPORTED_VERSIONS.toArray()[SUPPORTED_VERSIONS.size() - 1];
-      final ProtocolVersion to = current == next ? lastValid != null
-        ? lastValid : last : next.protocolVersion;
-
-      final ProtocolVersion lastInList = lastValid != null ? lastValid : last;
-
-      if (from.compareTo(to) >= 0 && from != lastInList) {
-        throw new IllegalArgumentException(String.format(
-          "Next mapping version (%s) should be lower then current (%s)", to, from));
-      }
-      return to;
+      return current == next ? LATEST_VERSION : next.protocolVersion;
     }
   }
 
   public static class ProtocolRegistry {
-    public final ProtocolVersion version;
+    private final ProtocolVersion version;
     private final IntObjectMap<Supplier<? extends FallbackPacket>> packetIdToSupplier =
       new IntObjectHashMap<>(16, 0.5f);
     private final Map<Class<? extends FallbackPacket>, Integer> packetClassToId =
@@ -386,7 +460,7 @@ public enum FallbackPacketRegistry {
       return supplier.get();
     }
 
-    public int getPacketId(final FallbackPacket packet) {
+    public int getPacketId(final @NotNull FallbackPacket packet) {
       final int id = packetClassToId.getOrDefault(packet.getClass(), Integer.MIN_VALUE);
 
       if (id == Integer.MIN_VALUE) {
@@ -401,22 +475,19 @@ public enum FallbackPacketRegistry {
     private final int id;
     private final ProtocolVersion protocolVersion;
     private final boolean encodeOnly;
-    private final ProtocolVersion lastValidProtocolVersion;
 
     PacketMapping(final int id,
                   final ProtocolVersion protocolVersion,
-                  final ProtocolVersion lastValidProtocolVersion,
                   final boolean packetDecoding) {
       this.id = id;
       this.protocolVersion = protocolVersion;
-      this.lastValidProtocolVersion = lastValidProtocolVersion;
       this.encodeOnly = packetDecoding;
     }
   }
 
-  private static PacketMapping map(final int id,
-                                   final ProtocolVersion version,
-                                   final boolean encodeOnly) {
-    return new PacketMapping(id, version, null, encodeOnly);
+  private static @NotNull PacketMapping map(final int id,
+                                            final ProtocolVersion version,
+                                            final boolean encodeOnly) {
+    return new PacketMapping(id, version, encodeOnly);
   }
 }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPreparer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,112 +18,90 @@
 package xyz.jonesdev.sonar.common.fallback.protocol;
 
 import lombok.experimental.UtilityClass;
-import net.kyori.adventure.nbt.BinaryTagIO;
-import net.kyori.adventure.nbt.BinaryTagTypes;
-import net.kyori.adventure.nbt.CompoundBinaryTag;
-import net.kyori.adventure.nbt.ListBinaryTag;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import xyz.jonesdev.sonar.api.ReflectiveOperationException;
 import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.api.config.SonarConfiguration;
 import xyz.jonesdev.sonar.common.fallback.protocol.block.BlockPosition;
 import xyz.jonesdev.sonar.common.fallback.protocol.block.BlockType;
 import xyz.jonesdev.sonar.common.fallback.protocol.block.ChangedBlock;
-import xyz.jonesdev.sonar.common.fallback.protocol.dimension.DimensionInfo;
-import xyz.jonesdev.sonar.common.fallback.protocol.packets.*;
-
-import java.io.InputStream;
-import java.util.Collections;
-import java.util.Objects;
-import java.util.Random;
-
-import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.*;
+import xyz.jonesdev.sonar.common.fallback.protocol.map.MapInfoPreparer;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.FinishConfigurationPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.RegistryDataPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;
 
 @UtilityClass
 public class FallbackPreparer {
-  private final Random RANDOM = new Random();
-  private final DimensionInfo DIMENSION = new DimensionInfo(
-    "minecraft:overworld",
-    "sonar", false, false
-  );
-
-  // Mappings
-  private final CompoundBinaryTag CHAT_TYPE_119;
-  private final CompoundBinaryTag CHAT_TYPE_1191;
-  private final CompoundBinaryTag DAMAGE_TYPE_1194;
-  private final CompoundBinaryTag DAMAGE_TYPE_120;
-
-  static {
-    CHAT_TYPE_119 = getMapping("chat_1_19.nbt");
-    CHAT_TYPE_1191 = getMapping("chat_1_19_1.nbt");
-    DAMAGE_TYPE_1194 = getMapping("damage_1_19_4.nbt");
-    DAMAGE_TYPE_120 = getMapping("damage_type_1_20.nbt");
-  }
-
-  // JoinGame
-  public JoinGame LEGACY_JOIN_GAME;
-  private JoinGame JOIN_GAME_1_16;
-  private JoinGame JOIN_GAME_1_16_2;
-  private JoinGame JOIN_GAME_1_18_2;
-  private JoinGame JOIN_GAME_1_19_1;
-  private JoinGame JOIN_GAME_1_19_4;
-  private JoinGame JOIN_GAME_1_20;
 
   // Abilities
-  public final Abilities DEFAULT_ABILITIES = new Abilities((byte) 0, 0f, 0f);
-
+  public final FallbackPacket DEFAULT_ABILITIES = new ClientAbilitiesPacket(0x00, 0f, 0f);
+  public final FallbackPacket CAPTCHA_ABILITIES = new ClientAbilitiesPacket(0x02, 0f, 0f);
   // Chunks
-  public final EmptyChunkData EMPTY_CHUNK_DATA = new EmptyChunkData(0, 0);
-  public PositionLook SPAWN_TELEPORT;
+  public final FallbackPacket EMPTY_CHUNK_DATA = new ChunkDataPacket(0, 0);
+  // Finish Configuration
+  public final FallbackPacket FINISH_CONFIGURATION = new FinishConfigurationPacket();
+  // Synchronize Registry
+  public final FallbackPacket REGISTRY_SYNC = new RegistryDataPacket();
+  // Keep Alive
+  public final FallbackPacket CAPTCHA_KEEP_ALIVE = new KeepAlivePacket(0L);
+  // Game Event (1.20.3+)
+  public final FallbackPacket START_WRITING_CHUNKS = new GameEventPacket(13, 0);
+  // Chat
+  public FallbackPacket enterCodeMessage;
+  public FallbackPacket incorrectCaptcha;
+  // JoinGame
+  public FallbackPacket joinGame;
+  // Update Section Blocks
+  public FallbackPacket updateSectionBlocks;
+  // Default Spawn Position
+  public FallbackPacket dynamicSpawnPosition;
+
+  // Disconnect messages
+  public FallbackPacket blacklisted;
+  public FallbackPacket alreadyQueued;
+  public FallbackPacket alreadyVerifying;
+  public FallbackPacket reconnectedTooFast;
+  public FallbackPacket protocolBlacklisted;
+  public FallbackPacket invalidUsername;
 
   // Collisions
-  public final int BLOCKS_PER_ROW = 8; // 8 * 8 = 64 (max)
-  private final int SPAWN_BUFFER = 10; // player spawns at 255 + 10 (10 blocks above the platform)
-  public final int DEFAULT_Y_COLLIDE_POSITION = 255; // 255 is max
+  public final int BLOCKS_PER_ROW = 8; // 8 * 8 = 64 (protocol maximum)
+  public final int SPAWN_X_POSITION = 16 / 2; // middle of the chunk
+  public final int SPAWN_Z_POSITION = 16 / 2; // middle of the chunk
+  public final int DEFAULT_Y_COLLIDE_POSITION = 255; // 255 is the maximum Y position allowed
 
-  public UpdateSectionBlocks UPDATE_SECTION_BLOCKS;
+  // Captcha position
+  public final FallbackPacket CAPTCHA_POSITION = new PlayerPositionLookPacket(
+    SPAWN_X_POSITION, 1337, SPAWN_Z_POSITION, 0f, 90f, 0, false);
+  public final FallbackPacket CAPTCHA_SPAWN_POSITION = new DefaultSpawnPositionPacket(
+    SPAWN_X_POSITION, 1337, SPAWN_Z_POSITION);
+
+  // Blocks
   private final ChangedBlock[] CHANGED_BLOCKS = new ChangedBlock[BLOCKS_PER_ROW * BLOCKS_PER_ROW];
+  public BlockType blockType = BlockType.BARRIER;
 
-  public int MAX_MOVEMENT_TICK;
-  public double[] PREPARED_MOVEMENT_PACKETS;
-  public int DYNAMIC_SPAWN_BUFFER = SPAWN_BUFFER;
-  public int DYNAMIC_SPAWN_Y_POSITION;
+  public int maxMovementTick, dynamicSpawnYPosition;
+  public double[] preparedCachedYMotions;
+  public double maxFallDistance;
 
   public void prepare() {
-    LEGACY_JOIN_GAME = createLegacyJoinGamePacket();
-    JOIN_GAME_1_16 = createJoinGamePacket(MINECRAFT_1_16);
-    JOIN_GAME_1_16_2 = createJoinGamePacket(MINECRAFT_1_16_2);
-    JOIN_GAME_1_18_2 = createJoinGamePacket(MINECRAFT_1_18_2);
-    JOIN_GAME_1_19_1 = createJoinGamePacket(MINECRAFT_1_19_1);
-    JOIN_GAME_1_19_4 = createJoinGamePacket(MINECRAFT_1_19_4);
-    JOIN_GAME_1_20 = createJoinGamePacket(MINECRAFT_1_20);
+    joinGame = new JoinGamePacket(1,
+      Sonar.get().getConfig().getVerification().getGravity().getGamemode().getId(),
+      0, false, 0,
+      true, false, false,
+      new String[]{"minecraft:overworld"}, "minecraft:overworld");
 
-    MAX_MOVEMENT_TICK = Sonar.get().getConfig().getMaximumMovementTicks();
-    PREPARED_MOVEMENT_PACKETS = new double[MAX_MOVEMENT_TICK + 1];
+    maxFallDistance = 0;
+    maxMovementTick = Sonar.get().getConfig().getVerification().getGravity().getMaxMovementTicks();
+    preparedCachedYMotions = new double[maxMovementTick + 8];
 
-    for (int i = 0; i < MAX_MOVEMENT_TICK + 1; i++) {
-      PREPARED_MOVEMENT_PACKETS[i] = -((Math.pow(0.98, i) - 1) * 3.92);
+    for (int i = 0; i < preparedCachedYMotions.length; i++) {
+      final double gravity = -((Math.pow(0.98, i) - 1) * 3.92);
+      preparedCachedYMotions[i] = gravity;
+      maxFallDistance += gravity;
     }
 
-    // Adjust block and collide Y position based on max movement ticks
-    double maxFallDistance = 0;
-    for (final double motion : PREPARED_MOVEMENT_PACKETS) {
-      maxFallDistance += motion;
-    }
-
-    // Set the dynamic spawn buffer
-    DYNAMIC_SPAWN_BUFFER = (int) (SPAWN_BUFFER + maxFallDistance);
     // Set the dynamic block and collide Y position based on the maximum fall distance
-    DYNAMIC_SPAWN_Y_POSITION = DEFAULT_Y_COLLIDE_POSITION + DYNAMIC_SPAWN_BUFFER;
-
-    // Prepare spawn PositionLook with the dynamic Y position
-    SPAWN_TELEPORT = new PositionLook(
-      8, DYNAMIC_SPAWN_Y_POSITION, 8,
-      0f, 0f,
-      RANDOM.nextInt(Short.MAX_VALUE),
-      false // 1.7 support
-    );
+    dynamicSpawnYPosition = DEFAULT_Y_COLLIDE_POSITION + (int) Math.ceil(maxFallDistance);
+    dynamicSpawnPosition = new DefaultSpawnPositionPacket(SPAWN_X_POSITION, dynamicSpawnYPosition, SPAWN_Z_POSITION);
 
     // Prepare collision platform positions
     int index = 0;
@@ -133,180 +111,29 @@ public class FallbackPreparer {
           x + (BLOCKS_PER_ROW / 2),
           DEFAULT_Y_COLLIDE_POSITION,
           z + (BLOCKS_PER_ROW / 2),
-          0, 0
-        );
-        CHANGED_BLOCKS[index++] = new ChangedBlock(position, BlockType.STONE);
+          0, 0);
+        CHANGED_BLOCKS[index++] = new ChangedBlock(position, blockType);
       }
     }
 
     // Prepare UpdateSectionBlocks packet
-    UPDATE_SECTION_BLOCKS = new UpdateSectionBlocks(0, 0, CHANGED_BLOCKS);
-  }
+    updateSectionBlocks = new UpdateSectionBlocksPacket(0, 0, CHANGED_BLOCKS);
 
-  private @Nullable CompoundBinaryTag getMapping(final @NotNull String fileName) {
-    try (final InputStream inputStream = Sonar.class.getResourceAsStream("/mappings/" + fileName)) {
-      return BinaryTagIO.unlimitedReader().read(Objects.requireNonNull(inputStream),
-        BinaryTagIO.Compression.GZIP
-      );
-    } catch (Throwable throwable) {
-      Sonar.get().getLogger().error("Could not load mapping {}", fileName);
-      throwable.printStackTrace(System.err);
-      return null;
+    // Prepare disconnect packets during login
+    blacklisted = DisconnectPacket.create(Sonar.get().getConfig().getVerification().getBlacklisted(), true);
+    alreadyVerifying = DisconnectPacket.create(Sonar.get().getConfig().getVerification().getAlreadyVerifying(), true);
+    alreadyQueued = DisconnectPacket.create(Sonar.get().getConfig().getVerification().getAlreadyQueued(), true);
+    protocolBlacklisted = DisconnectPacket.create(Sonar.get().getConfig().getVerification().getProtocolBlacklisted(), true);
+    reconnectedTooFast = DisconnectPacket.create(Sonar.get().getConfig().getVerification().getTooFastReconnect(), true);
+    invalidUsername = DisconnectPacket.create(Sonar.get().getConfig().getVerification().getInvalidUsername(), true);
+
+    // Precompute captcha answers
+    if (Sonar.get().getConfig().getVerification().getMap().getTiming() != SonarConfiguration.Verification.Timing.NEVER) {
+      enterCodeMessage = new UniversalChatPacket(Sonar.get().getConfig().getVerification().getMap().getEnterCode(), UniversalChatPacket.SYSTEM_TYPE);
+      incorrectCaptcha = new UniversalChatPacket(
+        Sonar.get().getConfig().getVerification().getMap().getFailedCaptcha(), UniversalChatPacket.SYSTEM_TYPE);
+
+      MapInfoPreparer.prepare();
     }
   }
-
-  public static JoinGame getJoinPacketForVersion(final ProtocolVersion protocolVersion) {
-    if (protocolVersion.compareTo(MINECRAFT_1_15_2) <= 0) {
-      return LEGACY_JOIN_GAME; // 1.7-1.15.2
-    }
-    if (protocolVersion.compareTo(MINECRAFT_1_16_1) <= 0) {
-      return JOIN_GAME_1_16; // 1.16-1.16.1
-    }
-    if (protocolVersion.compareTo(MINECRAFT_1_18) <= 0) {
-      return JOIN_GAME_1_16_2; // 1.16.2-1.18
-    }
-    if (protocolVersion.compareTo(MINECRAFT_1_19) <= 0) {
-      return JOIN_GAME_1_18_2; // 1.18.1-1.19
-    }
-    if (protocolVersion.compareTo(MINECRAFT_1_19_3) <= 0) {
-      return JOIN_GAME_1_19_1; // 1.19.1-1.19.3
-    }
-    if (protocolVersion.compareTo(MINECRAFT_1_19_4) <= 0) {
-      return JOIN_GAME_1_19_4; // 1.19.4
-    }
-    if (protocolVersion.compareTo(MINECRAFT_1_20) <= 0) {
-      return JOIN_GAME_1_20; // 1.20-1.20.1
-    }
-    throw new IllegalStateException("Unsupported protocol version");
-  }
-
-  private @NotNull JoinGame createLegacyJoinGamePacket() {
-    final JoinGame joinGame = new JoinGame();
-
-    joinGame.setLevelType("flat");
-    joinGame.setGamemode(Sonar.get().getConfig().getGamemodeId());
-    joinGame.setDimension(0);
-    joinGame.setReducedDebugInfo(true);
-    return joinGame;
-  }
-
-  // Partially taken from
-  // https://github.com/Elytrium/LimboAPI/blob/master/plugin/src/main/java/net/elytrium/limboapi/server/LimboImpl.java#L607
-  private @NotNull JoinGame createJoinGamePacket(final ProtocolVersion protocolVersion) {
-    final JoinGame joinGame = new JoinGame();
-
-    joinGame.setLevelType("flat");
-    joinGame.setGamemode(Sonar.get().getConfig().getGamemodeId());
-    joinGame.setDimension(0);
-    joinGame.setReducedDebugInfo(true);
-    joinGame.setDimensionInfo(DIMENSION);
-
-    final CompoundBinaryTag.Builder registryContainer = CompoundBinaryTag.builder();
-    final ListBinaryTag encodedDimensionRegistry = ListBinaryTag.builder(BinaryTagTypes.COMPOUND)
-      .add(createDimensionData(protocolVersion))
-      .build();
-
-    if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_16_2) >= 0) {
-      final CompoundBinaryTag.Builder dimensionRegistryEntry = CompoundBinaryTag.builder();
-
-      dimensionRegistryEntry.putString("type", "minecraft:dimension_type");
-      dimensionRegistryEntry.put("value", encodedDimensionRegistry);
-
-      registryContainer.put("minecraft:dimension_type", dimensionRegistryEntry.build());
-
-      final CompoundBinaryTag.Builder effectsTagBuilder = CompoundBinaryTag.builder()
-        .putInt("sky_color", 7907327)
-        .putInt("fog_color", 12638463)
-        .putInt("water_color", 0)
-        .putInt("water_fog_color", 0);
-
-      final CompoundBinaryTag.Builder elementTagBuilder = CompoundBinaryTag.builder()
-        .putFloat("depth", 0.125f)
-        .putFloat("temperature", 0.8f)
-        .putFloat("scale", 0.05f)
-        .putFloat("downfall", 0.4f)
-        .putString("category", "plains")
-        .put("effects", effectsTagBuilder.build());
-
-      if (protocolVersion.compareTo(MINECRAFT_1_19_4) >= 0) {
-        elementTagBuilder.putBoolean("has_precipitation", false);
-      } else {
-        elementTagBuilder.putString("precipitation", "rain");
-      }
-
-      registryContainer.put("minecraft:worldgen/biome", CompoundBinaryTag.builder()
-        .putString("type", "minecraft:worldgen/biome")
-        .put("value", ListBinaryTag.from(Collections.singletonList(
-          CompoundBinaryTag.builder()
-            .putString("name", "minecraft:plains")
-            .putInt("id", 1)
-            .put("element", elementTagBuilder.build())
-            .build()
-        ))).build()
-      );
-
-      if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_19) == 0) {
-        registryContainer.put("minecraft:chat_type", CHAT_TYPE_119);
-      } else if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_19_1) >= 0) {
-        registryContainer.put("minecraft:chat_type", CHAT_TYPE_1191);
-      }
-
-      if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_19_4) == 0) {
-        registryContainer.put("minecraft:damage_type", DAMAGE_TYPE_1194);
-      } else if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_20) >= 0) {
-        registryContainer.put("minecraft:damage_type", DAMAGE_TYPE_120);
-      }
-    } else {
-      registryContainer.put("dimension", encodedDimensionRegistry);
-    }
-
-    try {
-      CompoundBinaryTag currentDimensionData = encodedDimensionRegistry.getCompound(0);
-
-      if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_16_2) >= 0) {
-        currentDimensionData = currentDimensionData.getCompound("element");
-      }
-
-      joinGame.setCurrentDimensionData(currentDimensionData);
-      joinGame.setLevelNames(new String[]{"minecraft:overworld"});
-      joinGame.setRegistry(registryContainer.build());
-    } catch (Throwable throwable) {
-      throw new ReflectiveOperationException(throwable);
-    }
-    return joinGame;
-  }
-
-  public @NotNull CompoundBinaryTag createDimensionData(final @NotNull ProtocolVersion version) {
-    final CompoundBinaryTag details = CompoundBinaryTag.builder()
-      .putBoolean("natural", false)
-      .putFloat("ambient_light", 0f)
-      .putBoolean("shrunk", false)
-      .putBoolean("ultrawarm", false)
-      .putBoolean("has_ceiling", false)
-      .putBoolean("has_skylight", true)
-      .putBoolean("piglin_safe", false)
-      .putBoolean("bed_works", false)
-      .putBoolean("respawn_anchor_works", false)
-      .putBoolean("has_raids", false)
-      .putInt("logical_height", 256)
-      .putString("infiniburn", version.compareTo(ProtocolVersion.MINECRAFT_1_18_2) >= 0 ? "#minecraft" +
-        ":infiniburn_nether" : "minecraft:infiniburn_nether")
-      .putDouble("coordinate_scale", 1.0)
-      .putString("effects", "minecraft:overworld")
-      .putInt("min_y", 0)
-      .putInt("height", 256)
-      .putInt("monster_spawn_block_light_limit", 0)
-      .putInt("monster_spawn_light_level", 0)
-      .build();
-
-    if (version.compareTo(ProtocolVersion.MINECRAFT_1_16_2) >= 0) {
-      return CompoundBinaryTag.builder()
-        .putString("name", "minecraft:overworld")
-        .putInt("id", 0)
-        .put("element", details)
-        .build();
-    }
-
-    return details.putString("name", "minecraft:overworld");
-  }
 }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/block/BlockPosition.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/block/BlockType.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,19 +19,75 @@ package xyz.jonesdev.sonar.common.fallback.protocol.block;
 
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 
-import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT_1_13;
+import java.util.function.Function;
 
-@Getter
+@SuppressWarnings("unused")
 @RequiredArgsConstructor
 public enum BlockType {
-  STONE {
-    @Override
-    public int getId(final ProtocolVersion protocolVersion) {
-      return protocolVersion.compareTo(MINECRAFT_1_13) >= 0 ? 1 : 16;
+  STONE(protocolVersion -> 1, 1D),
+  BARRIER(protocolVersion -> {
+    // Useful resources:
+    // - https://github.com/PrismarineJS/minecraft-data/blob/master/data/pc/
+    // - https://pokechu22.github.io/Burger/1.20.4.html
+    // - https://github.com/ViaVersion/Mappings/tree/main/mappings
+    switch (protocolVersion) {
+      case MINECRAFT_1_7_2:
+      case MINECRAFT_1_7_6:
+        // We have to use glass for 1.7 since 1.7 doesn't have barrier blocks
+        return 20;
+      default:
+        // 1.8-1.12.2
+        return 166;
+      case MINECRAFT_1_13:
+      case MINECRAFT_1_13_1:
+        return 6493;
+      case MINECRAFT_1_13_2:
+        return 6494;
+      case MINECRAFT_1_14:
+      case MINECRAFT_1_14_1:
+      case MINECRAFT_1_14_2:
+      case MINECRAFT_1_14_3:
+      case MINECRAFT_1_14_4:
+      case MINECRAFT_1_15:
+      case MINECRAFT_1_15_1:
+      case MINECRAFT_1_15_2:
+        return 7000;
+      case MINECRAFT_1_16:
+      case MINECRAFT_1_16_1:
+        return 7536;
+      case MINECRAFT_1_16_2:
+      case MINECRAFT_1_16_3:
+      case MINECRAFT_1_16_4:
+        return 7540;
+      case MINECRAFT_1_17:
+      case MINECRAFT_1_17_1:
+      case MINECRAFT_1_18:
+      case MINECRAFT_1_18_2:
+        return 7754;
+      case MINECRAFT_1_19:
+      case MINECRAFT_1_19_1:
+        return 8245;
+      case MINECRAFT_1_19_3:
+        return 9889;
+      case MINECRAFT_1_19_4:
+        return 10221;
+      case MINECRAFT_1_20:
+        return 10225;
+      case MINECRAFT_1_20_2:
+      case MINECRAFT_1_20_3:
+        return 10366;
     }
-  };
+  }, 1D);
 
-  public abstract int getId(final ProtocolVersion protocolVersion);
+  private final Function<ProtocolVersion, Integer> idFunction;
+  // TODO: Implement per-version block heights?
+  @Getter
+  private final double blockHeight;
+
+  public int getId(final @NotNull ProtocolVersion protocolVersion) {
+    return idFunction.apply(protocolVersion);
+  }
 }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/block/ChangedBlock.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,18 +24,15 @@ import org.jetbrains.annotations.NotNull;
 public final class ChangedBlock {
   private final @NotNull BlockPosition position;
   private final BlockType type;
-  private final int legacyChunkPosCrammed;
-  private final int modernChunkPosCrammed;
+  private final int legacyBlockState, blockState;
 
   public ChangedBlock(final @NotNull BlockPosition position, final BlockType type) {
     this.position = position;
     this.type = type;
-    this.legacyChunkPosCrammed = position.getX()
-      - (position.getChunkX() << 4) << 12 | position.getZ()
-      - (position.getChunkZ() << 4) << 8 | position.getY();
-    this.modernChunkPosCrammed = position.getX()
-      - (position.getChunkX() << 4) << 8 | position.getZ()
-      - (position.getChunkZ() << 4) << 4 | position.getY()
-      - ((position.getY() >> 4) << 4);
+    final int x = position.getX() - (position.getChunkX() << 4);
+    final int y = position.getY();
+    final int z = position.getZ() - (position.getChunkZ() << 4);
+    this.legacyBlockState = x << 12 | z << 8 | y;
+    this.blockState = x << 8 | z << 4 | y - ((y >> 4) << 4);
   }
 }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/dimension/DimensionInfo.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,11 +20,13 @@ package xyz.jonesdev.sonar.common.fallback.protocol.dimension;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.ToString;
+import net.kyori.adventure.nbt.CompoundBinaryTag;
 
 @Getter
 @ToString
 @RequiredArgsConstructor
 public final class DimensionInfo {
-  private final String identifier, levelName;
-  private final boolean flat, debug;
+  private final String identifier;
+  private final int id;
+  private final CompoundBinaryTag tag;
 }