Release 2.0.17 (#191)

* feat: allow user to customize/configure blacklist time

* feat: implement customizable blacklist threshold

* feat: use caffeine for caching

.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,25 @@
 * 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).
+- [Fallback](https://github.com/jonesdevelopment/sonar#fallback) is Sonar's main anti-bot component
+- Sonar queues new player logins to prevent spam login attacks
+- Protective components only on BungeeCord:
+  - Sonar checks the handshake packets for legitimacy
+  - Sonar validates the login/server ping packets
+  - Sonar handles all server pings asynchronously
   - 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
 
-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 +59,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 +73,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 +82,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

build.gradle.kts

@@ -21,13 +21,10 @@ 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")
 
@@ -38,16 +35,20 @@ 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")
+    val adventureVersion = "4.15.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
+    // adventure
+    implementation("net.kyori:adventure-text-minimessage:$adventureVersion")
+    implementation("net.kyori:adventure-text-serializer-gson:$adventureVersion")
+    // adventure nbt
+    implementation("net.kyori:adventure-nbt:$adventureVersion")
 
-    compileOnly("io.netty:netty-all:4.1.99.Final") // netty
+    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.106.Final") // netty
+
+    // Library/dependency loading
+    compileOnly("com.alessiodp.libby:libby-core:2.0.0-SNAPSHOT")
   }
 }
 
@@ -69,10 +70,38 @@ 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
+
+    // bStats has to be relocated to the Sonar package otherwise it throws an exception
+    // https://github.com/Bastian/bstats-metrics/blob/master/base/src/main/java/org/bstats/MetricsBase.java#L251
+    relocate("org.bstats", "xyz.jonesdev.sonar.libs.bstats")
+
+    // https://github.com/jonesdevelopment/sonar/issues/46
+    // Relocate some packages, so we don't run into issues where we accidentally use Velocity's classes
+    relocate("com.alessiodp.libby", "xyz.jonesdev.sonar.libs.libby")
+    relocate("xyz.jonesdev.cappuccino", "xyz.jonesdev.sonar.libs.cappuccino")
+    // We have to be careful here, so we don't accidentally break adventure
+    relocate("net.kyori.adventure", "xyz.jonesdev.sonar.libs.adventure") {
+      exclude("net.kyori.adventure.text.**")
+      exclude("net.kyori.adventure.audience.Audience")
+      exclude("net.kyori.adventure.title.*")
+    }
+    relocate("net.kyori.examination", "xyz.jonesdev.sonar.libs.examination")
+    relocate("net.kyori.option", "xyz.jonesdev.sonar.libs.option")
+    // Relocate dynamically loaded libraries
+    relocate("com.simpleyaml", "xyz.jonesdev.sonar.libs.yaml")
+    relocate("com.google.code.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")
+    // We want to load our own Gson dynamically
+    exclude("com/google/gson/**")
+
+    // Exclude unnecessary metadata information
+    exclude("META-INF/versions/**")
   }
 
   compileJava {

gradle.properties

@@ -1,2 +1,3 @@
 group=xyz.jonesdev.sonar
-version=2.0.2
+version=2.0.17
+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.5-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,45 @@
 
 package xyz.jonesdev.sonar.api;
 
+import com.alessiodp.libby.LibraryManager;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import net.kyori.adventure.audience.Audience;
 import org.jetbrains.annotations.NotNull;
+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.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.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 public interface Sonar {
   DecimalFormat DECIMAL_FORMAT = new DecimalFormat("#,###.##");
   String LINE_SEPARATOR = "\n"; // Using System.lineSeparator is broken, for some reason...
 
+  Gson GENERAL_GSON = new GsonBuilder()
+    .disableInnerClassSerialization()
+    .create();
+
   /**
-   * @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();
+  Map<String, Audience> AUDIENCES = new ConcurrentHashMap<>();
+
+  /**
+   * @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 +72,49 @@ public interface Sonar {
 
   @NotNull Verbose getVerboseHandler();
 
+  @NotNull Notification getNotificationHandler();
+
+  @NotNull SystemTimer getLaunchTimer();
+
+  @NotNull LibraryManager getLibraryManager();
+
   /**
    * 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,158 @@
+/*
+ * 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.profiler.JVMProfiler;
+import xyz.jonesdev.sonar.api.statistics.Counters;
+import xyz.jonesdev.sonar.api.statistics.Statistics;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;
+
+import java.util.Optional;
+
+@Getter
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class AttackTracker implements JVMProfiler {
+  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 = Counters.LOGINS_PER_SECOND.estimatedSize();
+    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 = Statistics.FAILED_VERIFICATIONS.get();
+        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 = Counters.CONNECTIONS_PER_SECOND.estimatedSize();
+      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()) {
+          // 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 = Statistics.FAILED_VERIFICATIONS.get();
+          final long failed = Math.max(totalFailed - currentAttack.failedVerifications, 0);
+
+          // Post webhook to Discord
+          Optional.ofNullable(Sonar.get().getConfig().getDiscordWebhook()).ifPresent(webhook -> 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,17 @@ 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.function.Predicate;
 
 @Getter
 @RequiredArgsConstructor
 public abstract class InvocationSource {
   private final String name;
   private final Audience audience;
+  private final boolean player;
+  private final Predicate<String> permissionFunction;
 
   /**
    * Sends an empty chat message to the command executor
@@ -40,7 +44,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/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,6 +18,7 @@
 package xyz.jonesdev.sonar.api.config;
 
 import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
 import org.simpleyaml.configuration.comments.format.YamlCommentFormat;
 import org.simpleyaml.configuration.file.YamlFile;
 import xyz.jonesdev.sonar.api.Sonar;
@@ -36,9 +37,10 @@ public final class SimpleYamlConfig {
 
   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",
+    String.format("Running Sonar version %s on %s",
+      Sonar.get().getVersion(), Sonar.get().getPlatform().getDisplayName()),
+    "Need help or have questions? https://jonesdev.xyz/discord",
+    "https://github.com/jonesdevelopment/sonar",
     ""
   );
 
@@ -46,7 +48,7 @@ public final class SimpleYamlConfig {
     this(new File(dataFolder, fileName + ".yml"), dataFolder);
   }
 
-  private SimpleYamlConfig(final File file, final File folder) {
+  private SimpleYamlConfig(final File file, final @NotNull File folder) {
     if (!folder.exists() && !folder.mkdir()) {
       throw new IllegalStateException("Could not create folder?!");
     }
@@ -73,9 +75,7 @@ public final class SimpleYamlConfig {
     }
 
     // Always load the comment format and options
-    yaml.setCommentFormat(YamlCommentFormat.PRETTY);
-
-    yaml.options().headerFormatter().commentPrefix("# ");
+    yaml.setCommentFormat(YamlCommentFormat.DEFAULT);
     yaml.setHeader(String.join(LINE_SEPARATOR, HEADER));
   }
 
@@ -94,12 +94,27 @@ public final class SimpleYamlConfig {
   }
 
   public String getString(final String path, final String def) {
+    final Object object = getObject(path, def);
+    if (object instanceof String) {
+      return (String) object;
+    }
+    Sonar.get().getLogger().info("[config] Migrated {} to {}", path, def);
+    set(path, def);
+    return def;
+  }
+
+  public Object getObject(final String path, final Object def) {
     yaml.addDefault(path, def);
-    return yaml.getString(path, def);
+    return yaml.get(path, def);
   }
 
   public List<String> getStringList(final String path, final List<String> def) {
     yaml.addDefault(path, def);
     return yaml.getStringList(path);
   }
+
+  public List<Integer> getIntList(final String path, final List<Integer> def) {
+    yaml.addDefault(path, def);
+    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,23 @@ package xyz.jonesdev.sonar.api.controller;
 
 import com.j256.ormlite.dao.Dao;
 import com.j256.ormlite.dao.DaoManager;
+import com.j256.ormlite.jdbc.JdbcSingleConnectionSource;
 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.model.VerifiedPlayer;
 
+import java.lang.reflect.Method;
 import java.net.InetAddress;
-import java.sql.SQLException;
+import java.sql.*;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
@@ -45,19 +49,19 @@ public final class VerifiedPlayerController {
   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() {
     // Cache selected database type, so we don't need to call Sonar.get() every time
-    cachedDatabaseType = Sonar.get().getConfig().getDatabaseType();
+    cachedDatabaseType = Sonar.get().getConfig().getDatabase().getType();
 
     // Don't establish a database connection if the type is NONE
-    if (cachedDatabaseType == SonarConfiguration.DatabaseType.NONE) {
+    if (cachedDatabaseType == SonarConfiguration.Database.Type.NONE) {
       Sonar.get().getLogger().warn("Make sure to configure a database to save verified players.");
       return;
     }
 
-    try (final ConnectionSource connectionSource = DependencyLoader.setUpDriverAndConnect()) {
+    try (final ConnectionSource connectionSource = setupDriverAndConnect()) {
       this.connectionSource = connectionSource;
 
       // Create table
@@ -65,18 +69,96 @@ public final class VerifiedPlayerController {
         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);
+      // 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(() -> {
+        // Make sure to clear all outdated entries first
+        clearOld(Sonar.get().getConfig().getDatabase().getMaximumAge());
+        // Add all entries from the database to the cache
+        try {
+          dao.queryForAll().forEach(this::_add);
+        } catch (SQLException exception) {
+          Sonar.get().getLogger().error("Could not cache entries: {}", exception);
+        }
+      });
     } catch (Throwable throwable) {
-      Sonar.get().getLogger().error("Error setting up database connection: {}", throwable);
+      Sonar.get().getLogger().error("Error setting up database: {}", throwable);
       throwable.printStackTrace(System.err);
     }
   }
 
+  /**
+   * Automatically sets up the database connection using the configured credentials
+   */
+  private static @NotNull ConnectionSource setupDriverAndConnect() throws Throwable {
+    final SonarConfiguration.Database database = Sonar.get().getConfig().getDatabase();
+
+    // Prepare the JDBC connection string
+    // TODO: automatically build best connection string for database type
+    final String jdbcURL = String.format("jdbc:%s://%s:%d/%s",
+      database.getType().name().toLowerCase(), database.getUrl(), database.getPort(), database.getName());
+
+    // Use reflection to uncover the driver class
+    final Class<?> driverClass = Class.forName(database.getType().getDriverClassName());
+
+    // Make sure we send the username and password
+    final Properties credentials = new Properties();
+    credentials.put("user", database.getUsername());
+    credentials.put("password", database.getPassword());
+
+    // Return new JDBC connection instance for our controller to handle
+    return new JdbcSingleConnectionSource(jdbcURL, invoke(jdbcURL, driverClass, credentials));
+  }
+
+  /**
+   * Uses reflection to load the database driver from the injected library
+   *
+   * @param connectionString URL of the database
+   * @param driverClass      Class of the database driver
+   * @param credentials      Credentials for the database
+   */
+  private static Connection invoke(final @NotNull String connectionString,
+                                   final @NotNull Class<?> driverClass,
+                                   final @NotNull Properties credentials) throws Throwable {
+    final Object driver = driverClass.getDeclaredConstructor().newInstance();
+    DriverManager.registerDriver((Driver) driver);
+    final Method connect = driverClass.getDeclaredMethod("connect", String.class, Properties.class);
+    connect.setAccessible(true);
+    return (Connection) connect.invoke(driver, connectionString, credentials);
+  }
+
+  /**
+   * Clear all old entries using the given timestamp.
+   */
+  private void clearOld(final @Range(from = 1, to = 365) int maximumAge) {
+    try {
+      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);
+        }
+        Sonar.get().getLogger().info("Removed {} database entries older than {} days.",
+          oldEntries.size(), maximumAge);
+      }
+    } catch (SQLException exception) {
+      Sonar.get().getLogger().error("Error trying to clear old entries: {}", exception);
+    }
+  }
+
   /**
    * First, remove the player from the local cache and then,
    * secondly, asynchronously add the player to the database.
@@ -87,12 +169,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()
@@ -129,12 +215,16 @@ 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);
@@ -179,7 +269,7 @@ 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-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

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,13 +17,14 @@
 
 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;
@@ -31,14 +32,16 @@ import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 import xyz.jonesdev.sonar.api.statistics.Statistics;
 
 import java.net.InetAddress;
-import java.util.concurrent.TimeUnit;
+import java.time.Duration;
+import java.util.Objects;
 
-public interface FallbackUser<X, Y> {
+public interface FallbackUser<T> {
   @NotNull Fallback getFallback();
 
-  @NotNull X getPlayer();
-
-  @NotNull Y getConnection();
+  /**
+   * @return Per-platform connection object used internally
+   */
+  @NotNull T getConnection();
 
   @NotNull Channel getChannel();
 
@@ -48,17 +51,6 @@ public interface FallbackUser<X, Y> {
 
   @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.
@@ -72,9 +64,59 @@ public interface FallbackUser<X, Y> {
    *
    * @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
@@ -86,13 +128,10 @@ public interface FallbackUser<X, Y> {
    */
   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());
+      disconnect(Sonar.get().getConfig().getVerification().getVerificationFailed());
 
       if (reason != null) {
-        getFallback().getLogger().info(Sonar.get().getConfig().getVerificationFailedLog()
+        getFallback().getLogger().info(Sonar.get().getConfig().getVerification().getFailedLog()
           .replace("%ip%", Sonar.get().getConfig().formatAddress(getInetAddress()))
           .replace("%protocol%", String.valueOf(getProtocolVersion().getProtocol()))
           .replace("%reason%", reason));
@@ -101,21 +140,35 @@ public interface FallbackUser<X, Y> {
 
     Statistics.FAILED_VERIFICATIONS.increment();
 
-    // Make sure old entries are removed
-    PREVIOUS_FAILS.cleanUp();
+    // Call the VerifyFailedEvent for external API usage
+    Sonar.get().getEventManager().publish(new UserVerifyFailedEvent(this, reason));
 
-    // 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));
+    // 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;
 
-      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());
+      // 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));
+
+        getFallback().getBlacklist().put(getInetAddress(), (byte) 0);
+        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();
     }
   }
 }

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,13 +17,12 @@
 
 package xyz.jonesdev.sonar.api.fallback.protocol;
 
+import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 
-import java.util.EnumSet;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
+@Getter
 @RequiredArgsConstructor
 public enum ProtocolVersion {
   UNKNOWN(-1),
@@ -66,12 +65,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;
 
@@ -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;
@@ -96,7 +95,8 @@ public enum ProtocolVersion {
         }
       }
 
-      SUPPORTED_VERSIONS = versions;
+      SUPPORTED_VERSIONS = Collections.unmodifiableSet(versions);
+      LATEST_VERSION = (ProtocolVersion) versions.toArray()[versions.size() - 1];
     }
   }
 
@@ -104,14 +104,15 @@ 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;
   }
 
+  @SuppressWarnings("BooleanMethodIsAlwaysInverted")
   public boolean isLegacy() {
     return this == LEGACY;
   }

sonar-api/src/main/java/xyz/jonesdev/sonar/api/fallback/traffic/TrafficCounter.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/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/profiler/JVMProfiler.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
@@ -26,11 +26,16 @@ public interface JVMProfiler {
   Runtime RUNTIME = Runtime.getRuntime();
   OperatingSystemMXBean OPERATING_SYSTEM_MX_BEAN = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
   RuntimeMXBean RUNTIME_MX_BEAN = ManagementFactory.getRuntimeMXBean();
+  char[] MEMORY_UNITS = {'k', 'M', 'G', 'T', 'P', 'E'};
 
-  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 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];
+    return String.format("%.1f %sB", formattedSize, unit);
   }
 
   default int getVirtualCores() {

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

@@ -0,0 +1,33 @@
+/*
+ * 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 com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+
+import java.time.Duration;
+
+public interface Counters {
+  Cache<Long, Byte> LOGINS_PER_SECOND = Caffeine.newBuilder()
+    .expireAfterWrite(Duration.ofSeconds(1))
+    .build();
+
+  Cache<Long, Byte> CONNECTIONS_PER_SECOND = Caffeine.newBuilder()
+    .expireAfterWrite(Duration.ofSeconds(1))
+    .build();
+}

sonar-api/src/main/java/xyz/jonesdev/sonar/api/statistics/Statistics.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/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,79 @@
+/*
+ * 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.Counters;
+import xyz.jonesdev.sonar.api.statistics.Statistics;
+
+import java.util.Collection;
+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;
+
+@Getter
+public final class Notification implements Observable, Counters {
+  private final @NotNull Collection<String> subscribers = new Vector<>(0);
+
+  public void sendAttackNotification() {
+    // No need to do anything if we have no subscribers
+    if (subscribers.isEmpty()) {
+      return;
+    }
+    // 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.TOTAL_TRAFFIC.get()))
+      .replace("%logins-per-second%", DECIMAL_FORMAT.format(LOGINS_PER_SECOND.estimatedSize()))
+      .replace("%connections-per-second%", DECIMAL_FORMAT.format(CONNECTIONS_PER_SECOND.estimatedSize()))
+      .replace("%verify-total%", DECIMAL_FORMAT.format(Statistics.REAL_TRAFFIC.get()))
+      .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()));
+    // Send the title and chat messages to all online players
+    for (final String subscriber : Sonar.get().getNotificationHandler().getSubscribers()) {
+      final Audience audience = Sonar.AUDIENCES.get(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,48 @@
+/*
+ * 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;
+
+public interface Observable {
+  Collection<String> getSubscribers();
+
+  /**
+   * @param name Name of the audience
+   * @return Whether the audience is subscribed or not
+   */
+  default boolean isSubscribed(final @NotNull String name) {
+    return getSubscribers().contains(name);
+  }
+
+  /**
+   * @param name Name of the audience to subscribe
+   */
+  default void subscribe(final String name) {
+    getSubscribers().add(name);
+  }
+
+  /**
+   * @param name Name of the audience to unsubscribe
+   */
+  default void unsubscribe(final String name) {
+    getSubscribers().remove(name);
+  }
+}

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,9 +19,14 @@ 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.attack.AttackTracker;
 import xyz.jonesdev.sonar.api.profiler.JVMProfiler;
+import xyz.jonesdev.sonar.api.statistics.Counters;
 import xyz.jonesdev.sonar.api.statistics.Statistics;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
 
@@ -33,43 +38,49 @@ import static xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter.INCOMING;
 import static xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter.OUTGOING;
 
 @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, JVMProfiler, Counters {
+  private final @NotNull Collection<String> subscribers = new Vector<>(0);
+  private int animationIndex;
 
   // Run action bar verbose
-  public final void update() {
+  public 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;
-    }
+    Sonar.get().getFallback().getBlacklist().cleanUp();
+    // Clean up all counters
+    LOGINS_PER_SECOND.cleanUp();
+    CONNECTIONS_PER_SECOND.cleanUp();
 
+    // 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 String subscriber : subscribers) {
+      final Audience audience = Sonar.AUDIENCES.get(subscriber);
+      if (audience == null) continue;
+      audience.sendActionBar(component);
+    }
   }
 
-  protected @NotNull String prepareActionBarFormat() {
-    return Sonar.get().getConfig().getActionBarLayout()
+  public @NotNull Component prepareActionBarFormat() {
+    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))
+        DECIMAL_FORMAT.format(Sonar.get().getFallback().getBlacklist().estimatedSize()))
+      .replace("%total-joins%", DECIMAL_FORMAT.format(Statistics.TOTAL_TRAFFIC.get()))
+      .replace("%logins-per-second%", DECIMAL_FORMAT.format(LOGINS_PER_SECOND.estimatedSize()))
+      .replace("%connections-per-second%", DECIMAL_FORMAT.format(CONNECTIONS_PER_SECOND.estimatedSize()))
       .replace("%verify-total%", DECIMAL_FORMAT.format(Statistics.REAL_TRAFFIC.get()))
       .replace("%verify-success%",
         DECIMAL_FORMAT.format(Sonar.get().getVerifiedPlayerController().estimatedSize()))
       .replace("%verify-failed%", DECIMAL_FORMAT.format(Statistics.FAILED_VERIFICATIONS.get()))
+      .replace("%attack-duration%", attackDuration == null ? "00:00" : attackDuration.formattedDelay())
       .replace("%incoming-traffic%", INCOMING.getCachedSecond())
       .replace("%outgoing-traffic%", OUTGOING.getCachedSecond())
       .replace("%incoming-traffic-ttl%", INCOMING.getCachedTtl())
@@ -78,39 +89,12 @@ public abstract class Verbose implements JVMProfiler {
       .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,123 @@
+/*
+ * 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 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 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 Sonar.GENERAL_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,37 @@
 
 package xyz.jonesdev.sonar.bukkit;
 
+import com.alessiodp.libby.BukkitLibraryManager;
 import lombok.Getter;
+import net.kyori.adventure.platform.bukkit.BukkitAudiences;
 import org.bstats.bukkit.Metrics;
 import org.jetbrains.annotations.NotNull;
+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.audience.AudienceListener;
 import xyz.jonesdev.sonar.bukkit.command.BukkitSonarCommand;
-import xyz.jonesdev.sonar.bukkit.verbose.ActionBarVerbose;
 import xyz.jonesdev.sonar.common.boot.SonarBootstrap;
 
 import java.util.Objects;
-import java.util.Optional;
-import java.util.logging.Level;
 
 @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());
+
   /**
    * Create a wrapper for the plugin logger, so we can use it outside
    * the velocity module.
@@ -53,34 +58,17 @@ 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);
-    }
-  };
-
-  /**
-   * 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);
+      getPlugin().getLogger().severe(buildFullMessage(message, args));
     }
   };
 
@@ -88,26 +76,24 @@ public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
   public void enable() {
 
     // Initialize bStats.org metrics
-    new Metrics(getPlugin(), getServer().getPlatform().getMetricsId());
+    new Metrics(getPlugin(), getPlatform().getMetricsId());
 
     // 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 audience register listener
+    getPlugin().getServer().getPluginManager().registerEvents(new AudienceListener(), getPlugin());
 
-    // Register traffic counter reset task
-    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(), TrafficCounter::reset,
-      20L, 20L);
+    // Register traffic service
+    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
+      TrafficCounter::reset, 20L, 20L);
 
-    // Register action bar verbose task
-    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(), getVerboseHandler()::update,
-      2L, 2L);
-  }
+    // Register queue service
+    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
+      getFallback().getQueue().getPollTask(), 10L, 10L);
 
-  @Override
-  public void postReload() {
-    // Do nothing
+    // Register verbose service
+    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
+      Sonar.get().getVerboseHandler()::update, 4L, 4L);
   }
 }

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/audience/AudienceListener.java

@@ -0,0 +1,42 @@
+/*
+ * 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.bukkit.audience;
+
+import net.kyori.adventure.audience.Audience;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.bukkit.SonarBukkit;
+
+public final class AudienceListener implements Listener {
+
+  @EventHandler(priority = EventPriority.HIGHEST)
+  public void handle(final @NotNull PlayerJoinEvent event) {
+    final Audience audience = SonarBukkit.INSTANCE.getBukkitAudiences().player(event.getPlayer());
+    Sonar.AUDIENCES.put(event.getPlayer().getName(), audience);
+  }
+
+  @EventHandler(priority = EventPriority.HIGHEST)
+  public void handle(final @NotNull PlayerQuitEvent event) {
+    Sonar.AUDIENCES.remove(event.getPlayer().getName());
+  }
+}

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.getName(),
+      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,38 @@
 
 package xyz.jonesdev.sonar.bungee;
 
+import com.alessiodp.libby.BungeeLibraryManager;
 import lombok.Getter;
+import net.kyori.adventure.platform.bungeecord.BungeeAudiences;
 import org.bstats.bungeecord.Metrics;
 import org.jetbrains.annotations.NotNull;
+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.audience.AudienceListener;
 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.common.boot.SonarBootstrap;
 
-import java.util.Optional;
 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());
+
   /**
    * Create a wrapper for the plugin logger, so we can use it outside
    * the velocity module.
@@ -56,34 +59,17 @@ 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);
-    }
-  };
-
-  /**
-   * 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);
+      getPlugin().getLogger().severe(buildFullMessage(message, args));
     }
   };
 
@@ -91,31 +77,30 @@ public final class SonarBungee extends SonarBootstrap<SonarBungeePlugin> {
   public void enable() {
 
     // Initialize bStats.org metrics
-    new Metrics(getPlugin(), getServer().getPlatform().getMetricsId());
+    new Metrics(getPlugin(), getPlatform().getMetricsId());
 
     // 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 FallbackListener());
 
-    // 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,
-      1L, 1L, TimeUnit.SECONDS);
-
-    // Register action bar verbose task
-    getPlugin().getServer().getScheduler().schedule(getPlugin(), getVerboseHandler()::update,
-      100L, 100L, TimeUnit.MILLISECONDS);
+    // Register audience register listener
+    getPlugin().getServer().getPluginManager().registerListener(getPlugin(), new AudienceListener());
 
     // Inject base into ProtocolUtils
     BaseInjectionHelper.inject(ChildChannelInitializer.INSTANCE);
-  }
 
-  @Override
-  public void postReload() {
+    // Register traffic service
+    getPlugin().getServer().getScheduler().schedule(getPlugin(), TrafficCounter::reset,
+      1L, 1L, TimeUnit.SECONDS);
+
+    // Register queue service
+    getPlugin().getServer().getScheduler().schedule(getPlugin(), getFallback().getQueue().getPollTask(),
+      500L, 500L, TimeUnit.MILLISECONDS);
+
+    // Register verbose service
+    getPlugin().getServer().getScheduler().schedule(getPlugin(), Sonar.get().getVerboseHandler()::update,
+      200L, 200L, TimeUnit.MILLISECONDS);
   }
 }

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/audience/AudienceListener.java

@@ -0,0 +1,42 @@
+/*
+ * 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.audience;
+
+import net.kyori.adventure.audience.Audience;
+import net.md_5.bungee.api.event.PlayerDisconnectEvent;
+import net.md_5.bungee.api.event.PostLoginEvent;
+import net.md_5.bungee.api.plugin.Listener;
+import net.md_5.bungee.event.EventHandler;
+import net.md_5.bungee.event.EventPriority;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.bungee.SonarBungee;
+
+public final class AudienceListener implements Listener {
+
+  @EventHandler(priority = EventPriority.HIGHEST)
+  public void handle(final @NotNull PostLoginEvent event) {
+    final Audience audience = SonarBungee.INSTANCE.getBungeeAudiences().player(event.getPlayer());
+    Sonar.AUDIENCES.put(event.getPlayer().getName(), audience);
+  }
+
+  @EventHandler(priority = EventPriority.HIGHEST)
+  public void handle(final @NotNull PlayerDisconnectEvent event) {
+    Sonar.AUDIENCES.remove(event.getPlayer().getName());
+  }
+}

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.getName(),
+      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/FallbackHandlerBoss.java

@@ -0,0 +1,411 @@
+/*
+ * 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.ChannelFutureListener;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPipeline;
+import io.netty.handler.codec.CorruptedFrameException;
+import io.netty.handler.codec.haproxy.HAProxyMessage;
+import lombok.Getter;
+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.EncryptionUtil;
+import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.chat.ComponentSerializer;
+import net.md_5.bungee.connection.DownstreamBridge;
+import net.md_5.bungee.connection.UpstreamBridge;
+import net.md_5.bungee.netty.ChannelWrapper;
+import net.md_5.bungee.netty.HandlerBoss;
+import net.md_5.bungee.netty.PacketHandler;
+import net.md_5.bungee.protocol.PacketWrapper;
+import net.md_5.bungee.protocol.PlayerPublicKey;
+import net.md_5.bungee.protocol.packet.Handshake;
+import net.md_5.bungee.protocol.packet.Kick;
+import net.md_5.bungee.protocol.packet.LoginRequest;
+import net.md_5.bungee.protocol.packet.StatusRequest;
+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.event.impl.UserVerifyJoinEvent;
+import xyz.jonesdev.sonar.api.fallback.Fallback;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.api.statistics.Counters;
+import xyz.jonesdev.sonar.api.statistics.Statistics;
+import xyz.jonesdev.sonar.common.fallback.FallbackChannelHandler;
+import xyz.jonesdev.sonar.common.fallback.FallbackTimeoutHandler;
+import xyz.jonesdev.sonar.common.fallback.FallbackVerificationHandler;
+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.LoginSuccess;
+import xyz.jonesdev.sonar.common.fallback.traffic.TrafficChannelHooker;
+
+import java.lang.reflect.Field;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.time.Instant;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+
+import static net.md_5.bungee.netty.PipelineUtils.*;
+import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.*;
+import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT_1_19_1;
+import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT_1_19_3;
+import static xyz.jonesdev.sonar.common.utility.geyser.GeyserUtil.isGeyserConnection;
+
+public final class FallbackHandlerBoss extends HandlerBoss {
+  private static final @NotNull Fallback FALLBACK = Sonar.get().getFallback();
+  private static final @NotNull BungeeCord BUNGEE = BungeeCord.getInstance();
+
+  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);
+    }
+  }
+
+  private ChannelWrapper channelWrapper;
+  private PacketHandler handler;
+  private @Nullable FallbackUserWrapper user;
+  @Getter
+  private ProtocolVersion protocolVersion;
+  private boolean receivedLoginPacket;
+  private boolean receivedStatusPacket;
+
+  @Override
+  public void setHandler(final @NotNull PacketHandler handler) {
+    this.handler = handler;
+    super.setHandler(handler);
+  }
+
+  @Override
+  public void channelActive(final ChannelHandlerContext ctx) throws Exception {
+    if (handler != null) {
+      super.channelActive(ctx);
+      // Use the same channel wrapper as the "real" HandlerBoss
+      channelWrapper = (ChannelWrapper) CHANNEL_WRAPPER_FIELD.get(this);
+      // Increase connections per second for the action bar verbose
+      Counters.CONNECTIONS_PER_SECOND.put(System.nanoTime(), (byte) 0);
+    }
+  }
+
+  @Override
+  public void channelRead(final ChannelHandlerContext ctx, final Object msg) throws Exception {
+    if (msg instanceof HAProxyMessage || msg instanceof PacketWrapper) {
+      if (msg instanceof PacketWrapper) {
+        final PacketWrapper packetWrapper = (PacketWrapper) msg;
+        // Handle Handshake packets
+        if (packetWrapper.packet instanceof Handshake) {
+          final Handshake handshake = (Handshake) packetWrapper.packet;
+          // Check if the host is invalid
+          if (handshake.getHost().isEmpty()) {
+            throw new CorruptedFrameException("Hostname is empty");
+          }
+          // Set protocol version
+          protocolVersion = ProtocolVersion.fromId(handshake.getProtocolVersion());
+        }
+        // Handle StatusRequest packets
+        if (packetWrapper.packet instanceof StatusRequest) {
+          // Fix status packet spam exploit
+          if (receivedStatusPacket) {
+            throw new CorruptedFrameException("Duplicate status packet");
+          }
+          receivedStatusPacket = true;
+        }
+        // Handle LoginRequest packets
+        if (packetWrapper.packet instanceof LoginRequest) {
+          final LoginRequest loginRequest = (LoginRequest) packetWrapper.packet;
+
+          // Increase joins per second for the action bar verbose
+          Counters.LOGINS_PER_SECOND.put(System.nanoTime(), (byte) 0);
+
+          // Fix login packet spam exploit
+          if (receivedLoginPacket || user != null) {
+            throw new CorruptedFrameException("Duplicate login packet");
+          }
+          receivedLoginPacket = true;
+          // Cache protocol version so other handlers don't throw NPEs
+          final Channel channel = channelWrapper.getHandle();
+
+          // Run in the channel's event loop
+          channel.eventLoop().execute(() -> {
+
+            // Do not continue if the connection is closed or marked as disconnected
+            if (channelWrapper.isClosed() || channelWrapper.isClosing()) return;
+
+            try {
+              // Hook the custom traffic pipeline, so we can count the incoming and outgoing traffic
+              final ChannelPipeline pipeline = channel.pipeline();
+              TrafficChannelHooker.hook(pipeline, PACKET_DECODER, PACKET_ENCODER);
+
+              // Increase total traffic statistic
+              Statistics.TOTAL_TRAFFIC.increment();
+
+              // Use the ChannelWrapper's remote address to automatically handle proxy protocol
+              final InetSocketAddress socketAddress = (InetSocketAddress) channelWrapper.getRemoteAddress();
+              final InetAddress inetAddress = socketAddress.getAddress();
+
+              // Check the blacklist here since we cannot let the player "ghost join"
+              if (FALLBACK.getBlacklist().asMap().containsKey(inetAddress)) {
+                closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getBlacklisted()));
+                return;
+              }
+
+              // Check if the verification is enabled
+              if (!Sonar.get().getFallback().shouldVerifyNewPlayers()) {
+                super.channelRead(ctx, msg);
+                return;
+              }
+
+              // Completely skip Geyser connections
+              if (isGeyserConnection(channel, socketAddress)) {
+                FALLBACK.getLogger().info("Skipping Geyser player: {}{}",
+                  loginRequest.getData(), Sonar.get().getConfig().formatAddress(inetAddress));
+                super.channelRead(ctx, msg);
+                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())) {
+                closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getProtocolBlacklisted()));
+                return;
+              }
+
+              final UUID uuid = UUID.nameUUIDFromBytes(("OfflinePlayer:" + loginRequest.getData())
+                .getBytes(StandardCharsets.UTF_8));
+              // Check if the player is already verified
+              if (Sonar.get().getVerifiedPlayerController().has(inetAddress, uuid)) {
+                super.channelRead(ctx, msg);
+                return;
+              }
+
+              // Check if the protocol ID of the player is allowed to bypass verification
+              if (Sonar.get().getConfig().getVerification().getWhitelistedProtocols()
+                .contains(protocolVersion.getProtocol())) {
+                super.channelRead(ctx, msg);
+                return;
+              }
+
+              // Create wrapped Fallback user
+              user = new FallbackUserWrapper(
+                FALLBACK, this, channel, channel.pipeline(),
+                inetAddress, protocolVersion);
+
+              // Perform default BungeeCord checks
+              if (BUNGEE.config.isEnforceSecureProfile()
+                && user.getProtocolVersion().compareTo(MINECRAFT_1_19_3) < 0) {
+                final PlayerPublicKey publicKey = loginRequest.getPublicKey();
+                if (publicKey == null) {
+                  closeWith(getKickPacket(Component.text(BUNGEE.getTranslation("secure_profile_required"))));
+                  return;
+                }
+                if (Instant.ofEpochMilli(publicKey.getExpiry()).isBefore(Instant.now())) {
+                  closeWith(getKickPacket(BUNGEE.getTranslation("secure_profile_expired")));
+                  return;
+                }
+                if (user.getProtocolVersion().compareTo(MINECRAFT_1_19_1) < 0
+                  && !EncryptionUtil.check(publicKey, null)) {
+                  closeWith(getKickPacket(BUNGEE.getTranslation("secure_profile_invalid")));
+                  return;
+                }
+              }
+
+              // Check if the player is already queued since we don't want bots to flood the queue
+              if (FALLBACK.getQueue().getQueuedPlayers().containsKey(inetAddress)) {
+                closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getAlreadyQueued()));
+                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)) {
+                closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getAlreadyVerifying()));
+                return;
+              }
+
+              // Check if the IP address is currently being rate-limited
+              if (!FALLBACK.getRatelimiter().attempt(inetAddress)) {
+                closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getTooFastReconnect()));
+                return;
+              }
+
+              // We have to add this pipeline to monitor whenever the client disconnects
+              // to remove them from the list of connected and queued players
+              pipeline.addFirst(FALLBACK_HANDLER, new FallbackChannelHandler(loginRequest.getData(), inetAddress));
+
+              // Queue the connection for further processing
+              FALLBACK.getQueue().queue(inetAddress, () -> channel.eventLoop().execute(() -> {
+
+                // Do not continue if the connection is closed or marked as disconnected
+                if (channelWrapper.isClosed() || channelWrapper.isClosing()) return;
+
+                // 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()) {
+                  closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getInvalidUsername()));
+                  return;
+                }
+
+                // 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_HANDLER, TIMEOUT_HANDLER,
+                  new FallbackTimeoutHandler(readTimeout, TimeUnit.MILLISECONDS));
+
+                // Disconnect if the protocol version could not be resolved
+                if (user.getProtocolVersion().isUnknown()) {
+                  closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getInvalidProtocol()));
+                  return;
+                }
+
+                // Check if the player is already connected to the proxy but still tries to verify
+                final int limit = BUNGEE.config.getPlayerLimit();
+                if (limit > 0 && BUNGEE.getOnlineCount() >= limit) {
+                  closeWith(getKickPacket(BUNGEE.getTranslation("proxy_full")));
+                  return;
+                } else if (!BUNGEE.getConfig().isOnlineMode() && BUNGEE.getPlayer(loginRequest.getData()) != null) {
+                  closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getAlreadyConnected()));
+                  return;
+                }
+
+                // The player joined the verification
+                Statistics.REAL_TRAFFIC.increment();
+
+                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()) {
+                    FALLBACK.getLogger().info(Sonar.get().getConfig().getVerification().getConnectLog()
+                      .replace("%name%", loginRequest.getData())
+                      .replace("%ip%", Sonar.get().getConfig().formatAddress(inetAddress))
+                      .replace("%protocol%", String.valueOf(user.getProtocolVersion().getProtocol())));
+                  }
+                }
+
+                // Call the VerifyJoinEvent for external API usage
+                Sonar.get().getEventManager().publish(new UserVerifyJoinEvent(loginRequest.getData(), user));
+
+                // Mark the player as connected → verifying players
+                FALLBACK.getConnected().put(loginRequest.getData(), inetAddress);
+
+                // This sometimes happens when the channel hangs, but the player is still connecting
+                // This also fixes a unique issue with TCPShield and other reverse proxies
+                if (user.getPipeline().get(PACKET_ENCODER) == null
+                  || user.getPipeline().get(PACKET_DECODER) == null) {
+                  channelWrapper.close();
+                  return;
+                }
+
+                // Replace normal encoder to allow custom packets
+                final FallbackPacketEncoder encoder = new FallbackPacketEncoder(user.getProtocolVersion());
+                user.getPipeline().replace(PACKET_ENCODER, FALLBACK_PACKET_ENCODER, encoder);
+
+                // Send LoginSuccess packet to make the client think they are joining the server
+                user.write(new LoginSuccess(loginRequest.getData(), uuid));
+
+                // The LoginSuccess packet has been sent, now we can change the registry state
+                encoder.updateRegistry(user.getProtocolVersion().compareTo(ProtocolVersion.MINECRAFT_1_20_2) >= 0
+                  ? FallbackPacketRegistry.CONFIG : FallbackPacketRegistry.GAME);
+
+                // Replace normal decoder to allow custom packets
+                user.getPipeline().replace(PACKET_DECODER, FALLBACK_PACKET_DECODER,
+                  new FallbackPacketDecoder(user, new FallbackVerificationHandler(user, loginRequest.getData(), uuid)));
+              }));
+            } catch (Throwable throwable) {
+              throw new ReflectiveOperationException(throwable);
+            }
+          });
+          return;
+        }
+      }
+      super.channelRead(ctx, msg);
+    }
+  }
+
+  @Override
+  public void exceptionCaught(final @NotNull ChannelHandlerContext ctx, final Throwable throwable) {
+    if (ctx.channel().isActive()) {
+      if (handler instanceof DownstreamBridge || handler instanceof UpstreamBridge) {
+        try {
+          handler.exception(throwable);
+        } catch (Exception exception) {
+          ProxyServer.getInstance().getLogger().severe(handler + " - exception processing exception: " + exception);
+        }
+      }
+
+      channelWrapper.markClosed();
+      ctx.close();
+    }
+  }
+
+  private static final Map<Component, Kick> CACHED_KICK_PACKETS = new ConcurrentHashMap<>(10);
+
+  public static @NotNull Kick getKickPacket(final @NotNull String reason) {
+    final Component component = Component.text(reason);
+    return getKickPacket(component);
+  }
+
+  public static @NotNull Kick getKickPacket(final @NotNull Component component) {
+    Kick cachedKickPacket = CACHED_KICK_PACKETS.get(component);
+    if (cachedKickPacket == null) {
+      final String serialized = JSONComponentSerializer.json().serialize(component);
+      cachedKickPacket = new Kick(ComponentSerializer.deserialize(serialized));
+      CACHED_KICK_PACKETS.put(component, cachedKickPacket);
+    }
+    return cachedKickPacket;
+  }
+
+  public void closeWith(final Object msg) {
+    closeWith(channelWrapper, protocolVersion, msg);
+  }
+
+  // Mostly taken from Velocity
+  public static void closeWith(final @NotNull ChannelWrapper channelWrapper,
+                               final @NotNull ProtocolVersion protocolVersion,
+                               final @NotNull Object msg) {
+    if (channelWrapper.getHandle().isActive()) {
+      if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_8) < 0
+        && protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_7_2) >= 0) {
+        channelWrapper.getHandle().eventLoop().execute(() -> {
+          channelWrapper.getHandle().config().setAutoRead(false);
+          channelWrapper.getHandle().eventLoop().schedule(() -> {
+            channelWrapper.markClosed();
+            channelWrapper.getHandle().writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
+          }, 250L, TimeUnit.MILLISECONDS);
+        });
+      } else {
+        channelWrapper.markClosed();
+        channelWrapper.getHandle().writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
+      }
+    }
+  }
+}

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/FallbackListener.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,113 +17,61 @@
 
 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.event.LoginEvent;
 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.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.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 xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.bungee.SonarBungee;
 
 import java.lang.reflect.Field;
-
-import static net.md_5.bungee.netty.PipelineUtils.FRAME_PREPENDER;
+import java.net.InetAddress;
+import java.util.Objects;
 
 @RequiredArgsConstructor
 public final class FallbackListener implements Listener {
-  private final Fallback fallback;
 
-  private static final Field CHANNEL_WRAPPER;
+  private static final Field CHANNEL_FIELD;
 
   static {
     try {
-      CHANNEL_WRAPPER = InitialHandler.class.getDeclaredField("ch");
-      CHANNEL_WRAPPER.setAccessible(true);
-    } catch (Throwable throwable) {
-      throw new ReflectiveOperationException(throwable);
+      CHANNEL_FIELD = InitialHandler.class.getDeclaredField("ch");
+      CHANNEL_FIELD.setAccessible(true);
+    } catch (NoSuchFieldException exception) {
+      throw new ReflectiveOperationException(exception);
     }
   }
 
-  @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());
-        }
+  @EventHandler(priority = EventPriority.LOWEST)
+  public void handle(final @NotNull LoginEvent event) throws IllegalAccessException {
+    final InetAddress inetAddress = event.getConnection().getAddress().getAddress();
 
-        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()));
+    // 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();
+
+    if (maxOnlinePerIp > 0) {
+      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 PendingConnection connection = event.getConnection();
+        FallbackHandlerBoss.closeWith((ChannelWrapper) CHANNEL_FIELD.get(connection),
+          ProtocolVersion.fromId(connection.getVersion()), FallbackHandlerBoss.getKickPacket(component));
       }
     }
-
-    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/FallbackUserWrapper.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,42 +19,35 @@ 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 xyz.jonesdev.sonar.common.fallback.protocol.packets.play.Disconnect;
 
 import java.net.InetAddress;
 
 @Getter
 @RequiredArgsConstructor
-public final class FallbackUserWrapper implements FallbackUser<ChannelWrapper, FallbackInitialHandler> {
+public final class FallbackUserWrapper implements FallbackUser<FallbackHandlerBoss> {
   private final Fallback fallback;
-  private final ChannelWrapper player;
-  private final FallbackInitialHandler connection;
+  private final FallbackHandlerBoss connection;
   private final Channel channel;
   private final ChannelPipeline pipeline;
   private final InetAddress inetAddress;
   private final ProtocolVersion protocolVersion;
 
+  /**
+   * Disconnect the player during/after verification
+   * using our custom {@link Disconnect} packet.
+   *
+   * @param reason Disconnect message component
+   */
   @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,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,11 +22,11 @@ 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.FallbackHandlerBoss;
 import xyz.jonesdev.sonar.bungee.fallback.varint.Varint21FrameDecoder;
 import xyz.jonesdev.sonar.common.fallback.FallbackTimeoutHandler;
 
@@ -41,15 +41,13 @@ public final class BaseChannelInitializer extends ChannelInitializer<Channel> {
 
   private static final boolean REPLACE_VAR_INT_DECODER = !Boolean.getBoolean("sonar.do-not-replace-decoder");
 
-  private static final WriteBufferWaterMark MARK;
+  // https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/network/ConnectionManager.java#L57
+  private static final WriteBufferWaterMark SERVER_WRITE_MARK = new WriteBufferWaterMark(1 << 20, 1 << 21);
+
   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);
@@ -58,25 +56,25 @@ public final class BaseChannelInitializer extends ChannelInitializer<Channel> {
     }
   }
 
-  // Mostly taken from BungeeCord
+  // 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) {
+      // Use TCPNoDelay
+      channel.config().setOption(ChannelOption.TCP_NODELAY, true);
+    } catch (ChannelException exception) {
+      // IP_TOS is not supported (Windows XP / Windows Server 2003)
     }
-
-    channel.config().setOption(ChannelOption.TCP_NODELAY, true);
     channel.config().setAllocator(PooledByteBufAllocator.DEFAULT);
-    channel.config().setWriteBufferWaterMark(MARK);
+    channel.config().setWriteBufferWaterMark(SERVER_WRITE_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
-    ));
+      BungeeCord.getInstance().config.getTimeout(), TimeUnit.MILLISECONDS));
     channel.pipeline().addLast(FRAME_PREPENDER, FRAME_ENCODER);
-    channel.pipeline().addLast(BOSS_HANDLER, new HandlerBoss());
+    channel.pipeline().addLast(BOSS_HANDLER, new FallbackHandlerBoss());
   }
 }

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/injection/BaseInjectionHelper.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/fallback/injection/ChildChannelInitializer.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
@@ -23,15 +23,14 @@ 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.connection.InitialHandler;
 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 xyz.jonesdev.sonar.bungee.fallback.FallbackHandlerBoss;
 
 import java.lang.reflect.Field;
 import java.net.SocketAddress;
@@ -43,7 +42,7 @@ public final class ChildChannelInitializer extends ChannelInitializer<Channel> {
   public static final ChildChannelInitializer INSTANCE = new ChildChannelInitializer();
 
   private static final BaseChannelInitializer BASE = BaseChannelInitializer.INSTANCE;
-
+  private static final BungeeCord BUNGEE = BungeeCord.getInstance();
   private static final KickStringWriter LEGACY_KICK;
 
   static {
@@ -56,42 +55,36 @@ public final class ChildChannelInitializer extends ChannelInitializer<Channel> {
     }
   }
 
-  // Mostly taken from BungeeCord
+  // 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)) {
+    if (BUNGEE.getConnectionThrottle() != null && BUNGEE.getConnectionThrottle().throttle(remoteAddress)) {
       channel.close();
-    } else {
-      final ListenerInfo listener = channel.attr(PipelineUtils.LISTENER).get();
+      return;
+    }
 
-      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;
-        }
+    final ListenerInfo listener = channel.attr(PipelineUtils.LISTENER).get();
 
-        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 (BungeeCord.getInstance().getPluginManager().callEvent(new ClientConnectEvent(remoteAddress, listener)).isCancelled()) {
+      channel.close();
+      return;
+    }
 
-        if (listener.isProxyProtocol()) {
-          channel.pipeline().addFirst(new HAProxyMessageDecoder());
-        }
-      }
+    BASE.initChannel(channel);
+    channel.pipeline().addBefore(FRAME_DECODER, LEGACY_DECODER, new LegacyDecoder());
+    channel.pipeline().addAfter(FRAME_DECODER, PACKET_DECODER, new MinecraftDecoder(
+      Protocol.HANDSHAKE, true, BUNGEE.getProtocolVersion()));
+    channel.pipeline().addAfter(FRAME_PREPENDER, PACKET_ENCODER, new MinecraftEncoder(
+      Protocol.HANDSHAKE, true, BUNGEE.getProtocolVersion()));
+    channel.pipeline().addBefore(FRAME_PREPENDER, LEGACY_KICKER, LEGACY_KICK);
+    channel.pipeline().get(FallbackHandlerBoss.class).setHandler(new InitialHandler(BUNGEE, listener));
+
+    if (listener.isProxyProtocol()) {
+      channel.pipeline().addFirst(new HAProxyMessageDecoder());
     }
   }
 }

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/varint/Varint21FrameDecoder.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,7 @@ import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.ByteToMessageDecoder;
 import io.netty.handler.codec.CorruptedFrameException;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 
@@ -29,7 +30,7 @@ import java.util.List;
 public final class Varint21FrameDecoder extends ByteToMessageDecoder {
 
   @Override
-  protected void decode(final ChannelHandlerContext ctx,
+  protected void decode(final @NotNull ChannelHandlerContext ctx,
                         final ByteBuf byteBuf,
                         final List<Object> out) throws Exception {
     if (!ctx.channel().isActive() || !byteBuf.isReadable()) {

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/fallback/varint/VarintByteDecoder.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/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,68 @@
+/*
+ * 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
+      // TODO: use a different library for config management?
+      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{}code{}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
+      Library.builder()
+        .groupId("com{}mysql")
+        .artifactId("mysql-connector-j")
+        .version("8.3.0")
+        .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,27 @@
 
 package xyz.jonesdev.sonar.common.boot;
 
+import com.alessiodp.libby.LibraryManager;
+import com.github.benmanes.caffeine.cache.Caffeine;
 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.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.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,22 +45,32 @@ 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 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.verboseHandler = new Verbose();
+    this.notificationHandler = new Notification();
     this.config = new SonarConfiguration(dataDirectory);
     this.subcommandRegistry = new SubcommandRegistryHolder();
   }
@@ -90,8 +101,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();
@@ -102,32 +117,46 @@ public abstract class SonarBootstrap<T> implements Sonar {
 
     // 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"
+      && getVerifiedPlayerController().getCachedDatabaseType() != getConfig().getDatabase().getType()) {
+      getLogger().warn("Reloading the server after changing the database type"
         + " is generally not recommended as it can sometimes 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
     verifiedPlayerController = new VerifiedPlayerController();
-
-    // Call post reload task
-    postReload();
   }
 
-  public abstract void postReload();
-
   public void shutdown() {
     getLogger().info("Starting shutdown process...");
+
     // ...
+
     getLogger().info("Successfully shut down. Goodbye!");
   }
 }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackChannelHandler.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,25 +20,25 @@ package xyz.jonesdev.sonar.common.fallback;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
 import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
 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;
+  private static final @NotNull Fallback FALLBACK = Sonar.get().getFallback();
+  private final @NotNull String username;
+  private final @NotNull InetAddress inetAddress;
 
   @Override
-  public void channelUnregistered(final ChannelHandlerContext ctx) {
-    final InetAddress inetAddress = ((InetSocketAddress) ctx.channel().remoteAddress()).getAddress();
-
-    // Remove the IP address from the queue
+  public void channelUnregistered(final @NotNull ChannelHandlerContext ctx) {
+    // Remove the username from the connected players
     FALLBACK.getConnected().remove(username);
+    // Remove the IP address from the queue
     FALLBACK.getQueue().remove(inetAddress);
-
+    // Make sure other handlers also know we've disconnected
     ctx.fireChannelUnregistered();
   }
 }

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/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,124 @@ 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.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.FinishConfiguration;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginAcknowledged;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;
 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.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();
 
-  @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);
+  // 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
 
-    private final boolean canMove;
+  // Checks
+  private short expectedTransactionId;
+  private int expectedKeepAliveId, expectedTeleportId = -1;
+  private int tick, totalReceivedPackets, ignoredMovementTicks;
+  private double posX, posY, posZ, lastY;
+  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;
+
+  public enum State {
+    // 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
+      user.getFallback().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 KeepAlive(expectedKeepAliveId));
     }
   }
 
@@ -99,50 +145,93 @@ 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 Transaction(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 (the player is in spectator mode)
+    user.delayedWrite(DEFAULT_ABILITIES);
+    // Generate the current teleport ID
+    expectedTeleportId = RANDOM.nextInt(Short.MAX_VALUE);
+    // Teleport the player to the spawn position
+    user.delayedWrite(new PositionLook(
+      SPAWN_X_POSITION, dynamicSpawnYPosition, 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() {
     // 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);
     // 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);
+    // Checking gravity is disabled, just finish verification
+    if (!Sonar.get().getConfig().getVerification().getGravity().isEnabled()) {
+      // Switch to captcha state if needed
+      captchaOrFinish();
+    } else {
+      // Make sure the player knows we are checking them
+      user.delayedWrite(youAreBeingChecked);
+      // 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().getMaxBrandLength()) {
+        return false;
+      }
       // Regex pattern for validating client brands
-      final Pattern pattern = Sonar.get().getConfig().getValidBrandRegex();
+      final Pattern pattern = Sonar.get().getConfig().getVerification().getValidBrandRegex();
       return !read.equals("Vanilla") // The normal brand is always lowercase
         && pattern.matcher(read).matches(); // Disallow non-ascii characters (by default)
     } catch (DecoderException exception) {
@@ -155,19 +244,89 @@ 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");
-
+    // The player has already been verified, drop all other packets
+    if (state == State.SUCCESS) return;
     // Check for timeout since the player could be sending packets but not important ones
-    final long timeout = Sonar.get().getConfig().getVerificationTimeout();
+    final long timeout = Sonar.get().getConfig().getVerification().getMaxPing();
+    // We are expecting a captcha code in chat, drop all other packets
+    if (state == State.MAP_CAPTCHA) {
+      // 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");
+
+      // Handle incoming chat messages
+      if (packet instanceof Chat) {
+        final Chat chat = (Chat) 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;
+      }
+
+      // 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 Chat(MiniMessage.miniMessage().deserialize(
+            actionBarMessage.replace("%time-left%", timeLeft)), Chat.GAME_INFO_TYPE));
+          // Make sure to reset the timer
+          actionBar.reset();
+        }
+      }
+
+      // Every about 10 seconds
+      if (keepAlive.elapsed(timeout)) {
+        // Send the message again to remind the player
+        user.delayedWrite(enterCodeMessage);
+        // 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();
+      }
+      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 if the time limit has exceeded
     if (login.elapsed(timeout)) {
       user.getChannel().close();
       return;
     }
 
+    if (packet instanceof LoginAcknowledged) {
+      // 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 FinishConfiguration) {
+      // 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 KeepAlive) {
       final KeepAlive keepAlive = (KeepAlive) packet;
 
@@ -177,7 +336,7 @@ 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();
@@ -193,14 +352,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;
 
-      // 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
@@ -216,6 +381,9 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
           // Send the transaction packet
           sendTransaction();
         }
+
+        // Make sure we mark the PluginMessage as valid
+        resolvedClientBrand = true;
       }
     }
 
@@ -228,27 +396,21 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
       // 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();
       }
     }
 
@@ -256,108 +418,164 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
       // Check if we are currently expecting a TeleportConfirm packet
       assertState(State.TELEPORT);
 
+      // Check if the teleport ID is correct
       final TeleportConfirm teleportConfirm = (TeleportConfirm) 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 (state != State.LOGIN_ACK) {
       if (packet instanceof Position) {
         final Position position = (Position) packet;
-
-        // Immediately handle new position update
         handlePositionUpdate(position.getX(), position.getY(), position.getZ(), position.isOnGround());
       }
 
       if (packet instanceof PositionLook) {
         final PositionLook position = (PositionLook) packet;
-
-        // Immediately handle new position update
         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());
+        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 == dynamicSpawnYPosition && 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 = dynamicSpawnYPosition;
+      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
+    final double collisionOffsetY = DEFAULT_Y_COLLIDE_POSITION - y;
+
+    // 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()) {
+        user.getFallback().getLogger().info("{}: {}/{}/{} - deltaY: {} - ground: {} - collision: {}",
+          username, x, y, z, deltaY, ground, collisionOffsetY);
+      }
+
+      // The player is colliding to blocks, finish verification
+      if (ground) {
+        captchaOrFinish();
+        return;
+      }
+    } 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()) {
+        user.getFallback().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 (user.getFallback().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 assertState(final @NotNull State expectedState) {
-    if (expectedState != state) {
-      user.fail("expected " + expectedState + ", got " + state);
-    }
-  }
+  private void handleMapCaptcha() {
+    // Reset max tries
+    captchaTriesLeft = Sonar.get().getConfig().getVerification().getMap().getMaxTries();
 
-  private void checkFrame(final boolean condition, final String message) {
-    if (!condition) {
-      user.fail(message);
-      throw new CorruptedFrameException(message);
-    }
+    // Set slot to map
+    user.delayedWrite(new SetSlot(0, 36, 1, 0,
+      ItemMapType.FILLED_MAP.getId(user.getProtocolVersion()), SetSlot.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() {
@@ -366,17 +584,40 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     user.getFallback().getConnected().remove(username);
 
     // Add verified player to the database
-    final VerifiedPlayer verifiedPlayer = new VerifiedPlayer(user.getInetAddress().toString(), uuid, login.getStart());
+    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, uuid, user, login.delay()));
+    Sonar.get().getEventManager().publish(new UserVerifySuccessEvent(username, playerUuid, user, login.delay()));
 
     // Disconnect player with the verification success message
-    user.disconnect(Sonar.get().getConfig().getVerificationSuccess());
+    user.disconnect(Sonar.get().getConfig().getVerification().getVerificationSuccess());
 
-    user.getFallback().getLogger().info(Sonar.get().getConfig().getVerificationSuccessfulLog()
+    user.getFallback().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) {
+    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);
+    }
+  }
 }

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.FinishConfiguration;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.RegistryData;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginAcknowledged;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginSuccess;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;
 
 import java.util.*;
 import java.util.function.Supplier;
@@ -32,16 +36,38 @@ 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(LoginAcknowledged.class, LoginAcknowledged::new,
+        map(0x03, MINECRAFT_1_20_2, false));
 
-      // LOGIN
-      clientbound.register(ServerLoginSuccess.class, ServerLoginSuccess::new,
+      clientbound.register(LoginSuccess.class, LoginSuccess::new,
         map(0x02, MINECRAFT_1_7_2, false));
+    }
+  },
+  CONFIG {
+    {
+      clientbound.register(Disconnect.class, Disconnect::new,
+        map(0x01, MINECRAFT_1_20_2, true));
+      clientbound.register(FinishConfiguration.class, FinishConfiguration::new,
+        map(0x02, MINECRAFT_1_20_2, false));
+      clientbound.register(KeepAlive.class, KeepAlive::new,
+        map(0x03, MINECRAFT_1_20_2, false));
+      clientbound.register(RegistryData.class, RegistryData::new,
+        map(0x05, MINECRAFT_1_20_2, true));
 
-      // GAME
+      serverbound.register(ClientSettings.class, ClientSettings::new,
+        map(0x00, MINECRAFT_1_20_2, false));
+      serverbound.register(PluginMessage.class, PluginMessage::new,
+        map(0x01, MINECRAFT_1_20_2, false));
+      serverbound.register(FinishConfiguration.class, FinishConfiguration::new,
+        map(0x02, MINECRAFT_1_20_2, false));
+      serverbound.register(KeepAlive.class, KeepAlive::new,
+        map(0x03, MINECRAFT_1_20_2, false));
+    }
+  },
+  GAME {
+    {
       clientbound.register(JoinGame.class, JoinGame::new,
         map(0x01, MINECRAFT_1_7_2, true),
         map(0x23, MINECRAFT_1_9, true),
@@ -54,7 +80,8 @@ 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));
+        map(0x28, MINECRAFT_1_19_4, true),
+        map(0x29, MINECRAFT_1_20_2, true));
       clientbound.register(KeepAlive.class, KeepAlive::new,
         map(0x00, MINECRAFT_1_7_2, false),
         map(0x1F, MINECRAFT_1_9, false),
@@ -67,7 +94,8 @@ 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));
+        map(0x23, MINECRAFT_1_19_4, false),
+        map(0x24, MINECRAFT_1_20_2, false));
       clientbound.register(Disconnect.class, Disconnect::new,
         map(0x40, MINECRAFT_1_7_2, true),
         map(0x1A, MINECRAFT_1_9, true),
@@ -80,7 +108,8 @@ 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));
+        map(0x1A, MINECRAFT_1_19_4, true),
+        map(0x1B, MINECRAFT_1_20_2, true));
       clientbound.register(PositionLook.class, PositionLook::new,
         map(0x08, MINECRAFT_1_7_2, true),
         map(0x2E, MINECRAFT_1_9, true),
@@ -94,7 +123,8 @@ 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));
+        map(0x3C, MINECRAFT_1_19_4, true),
+        map(0x3E, MINECRAFT_1_20_2, true));
       clientbound.register(Abilities.class, Abilities::new,
         map(0x39, MINECRAFT_1_7_2, true),
         map(0x2B, MINECRAFT_1_9, true),
@@ -108,7 +138,8 @@ 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));
+        map(0x34, MINECRAFT_1_19_4, true),
+        map(0x36, MINECRAFT_1_20_2, true));
       clientbound.register(EmptyChunkData.class, EmptyChunkData::new,
         map(0x21, MINECRAFT_1_7_2, true),
         map(0x20, MINECRAFT_1_9, true),
@@ -121,19 +152,35 @@ 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));
+        map(0x24, MINECRAFT_1_19_4, true),
+        map(0x25, MINECRAFT_1_20_2, true));
       clientbound.register(UpdateSectionBlocks.class, UpdateSectionBlocks::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));
+        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(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(0x33, MINECRAFT_1_20_2, true));
       clientbound.register(DefaultSpawnPosition.class, DefaultSpawnPosition::new,
         map(0x05, MINECRAFT_1_7_2, true),
         map(0x43, MINECRAFT_1_9, true),
@@ -147,20 +194,60 @@ 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(MapData.class, MapData::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(SetSlot.class, SetSlot::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(Chat.class, Chat::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(GameEvent.class, GameEvent::new,
+        map(0x20, MINECRAFT_1_20_3, true));
 
+      serverbound.register(Chat.class, Chat::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(KeepAlive.class, KeepAlive::new,
         map(0x00, MINECRAFT_1_7_2, false),
         map(0x0B, MINECRAFT_1_9, false),
@@ -173,7 +260,9 @@ 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));
+        map(0x12, MINECRAFT_1_19_4, false),
+        map(0x14, MINECRAFT_1_20_2, false),
+        map(0x15, MINECRAFT_1_20_3, false));
       serverbound.register(ClientSettings.class, ClientSettings::new,
         map(0x15, MINECRAFT_1_7_2, false),
         map(0x04, MINECRAFT_1_9, false),
@@ -183,7 +272,8 @@ 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));
+        map(0x08, MINECRAFT_1_19_4, false),
+        map(0x09, MINECRAFT_1_20_2, false));
       serverbound.register(PluginMessage.class, PluginMessage::new,
         map(0x17, MINECRAFT_1_7_2, false),
         map(0x09, MINECRAFT_1_9, false),
@@ -195,7 +285,8 @@ 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));
+        map(0x0D, MINECRAFT_1_19_4, false),
+        map(0x0F, MINECRAFT_1_20_2, false));
       serverbound.register(PositionLook.class, PositionLook::new,
         map(0x06, MINECRAFT_1_7_2, false),
         map(0x0D, MINECRAFT_1_9, false),
@@ -208,7 +299,9 @@ 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));
+        map(0x15, MINECRAFT_1_19_4, false),
+        map(0x17, MINECRAFT_1_20_2, false),
+        map(0x18, MINECRAFT_1_20_3, false));
       serverbound.register(TeleportConfirm.class, TeleportConfirm::new,
         map(0x00, MINECRAFT_1_9, false));
       serverbound.register(Position.class, Position::new,
@@ -223,7 +316,9 @@ 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));
+        map(0x14, MINECRAFT_1_19_4, false),
+        map(0x16, MINECRAFT_1_20_2, false),
+        map(0x17, MINECRAFT_1_20_3, false));
       serverbound.register(Player.class, Player::new,
         map(0x03, MINECRAFT_1_7_2, false),
         map(0x0F, MINECRAFT_1_9, false),
@@ -236,7 +331,9 @@ 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));
+        map(0x17, MINECRAFT_1_19_4, false),
+        map(0x19, MINECRAFT_1_20_2, false),
+        map(0x1A, MINECRAFT_1_20_3, false));
       serverbound.register(Transaction.class, Transaction::new,
         map(0x0F, MINECRAFT_1_7_2, false),
         map(0x05, MINECRAFT_1_9, false),
@@ -248,7 +345,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 +366,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()) {
+      final Map<ProtocolVersion, ProtocolRegistry> mutableVersions = new EnumMap<>(ProtocolVersion.class);
+      for (final ProtocolVersion version : ProtocolVersion.values()) {
         if (!version.isLegacy() && !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 +404,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 +433,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 +457,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 +472,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,87 @@
 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.FinishConfiguration;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.RegistryData;
+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 Abilities(0x00, 0f, 0f);
+  public final FallbackPacket CAPTCHA_ABILITIES = new Abilities(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 EmptyChunkData(0, 0);
+  // Finish Configuration
+  public final FallbackPacket FINISH_CONFIGURATION = new FinishConfiguration();
+  // Synchronize Registry
+  public final FallbackPacket REGISTRY_SYNC = new RegistryData();
+  // Keep Alive
+  public final FallbackPacket CAPTCHA_KEEP_ALIVE = new KeepAlive(0L);
+  // Game Event (1.20.3+)
+  public final FallbackPacket START_WRITING_CHUNKS = new GameEvent(13, 0);
+  // Chat
+  public FallbackPacket enterCodeMessage;
+  public FallbackPacket youAreBeingChecked;
+  public FallbackPacket incorrectCaptcha;
+  // JoinGame
+  public FallbackPacket joinGame;
+  // Update Section Blocks
+  public FallbackPacket updateSectionBlocks;
+  // Default Spawn Position
+  public FallbackPacket dynamicSpawnPosition;
 
   // 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 PositionLook(
+    SPAWN_X_POSITION, 1337, SPAWN_Z_POSITION, 0f, 90f, 0, false);
+  public final FallbackPacket CAPTCHA_SPAWN_POSITION = new DefaultSpawnPosition(
+    SPAWN_X_POSITION, 1337, SPAWN_Z_POSITION);
+
+  // Blocks
   private final ChangedBlock[] CHANGED_BLOCKS = new ChangedBlock[BLOCKS_PER_ROW * BLOCKS_PER_ROW];
 
-  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 JoinGame(0,
+      Sonar.get().getConfig().getVerification().getGravity().getGamemode().getId(),
+      0,
+      false,
+      0,
+      true,
+      true,
+      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 DefaultSpawnPosition(SPAWN_X_POSITION, dynamicSpawnYPosition, SPAWN_Z_POSITION);
 
     // Prepare collision platform positions
     int index = 0;
@@ -133,180 +108,25 @@ 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.BARRIER);
       }
     }
 
     // Prepare UpdateSectionBlocks packet
-    UPDATE_SECTION_BLOCKS = new UpdateSectionBlocks(0, 0, CHANGED_BLOCKS);
-  }
+    updateSectionBlocks = new UpdateSectionBlocks(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;
-    }
-  }
-
-  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);
+    // "You are being checked" message
+    if (Sonar.get().getConfig().getVerification().getGravity().isEnabled()) {
+      youAreBeingChecked = new Chat(Sonar.get().getConfig().getVerification().getGravity().getYouAreBeingChecked());
     }
 
-    try {
-      CompoundBinaryTag currentDimensionData = encodedDimensionRegistry.getCompound(0);
+    if (Sonar.get().getConfig().getVerification().getMap().getTiming() != SonarConfiguration.Verification.Timing.NEVER) {
+      enterCodeMessage = new Chat(Sonar.get().getConfig().getVerification().getMap().getEnterCode());
+      incorrectCaptcha = new Chat(Sonar.get().getConfig().getVerification().getMap().getFailedCaptcha());
 
-      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);
+      // Precompute captcha answers
+      MapInfoPreparer.prepare();
     }
-    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
@@ -17,21 +17,73 @@
 
 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),
+  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;
     }
-  };
+  });
 
-  public abstract int getId(final ProtocolVersion protocolVersion);
+  private final Function<ProtocolVersion, Integer> function;
+
+  public int getId(final @NotNull ProtocolVersion protocolVersion) {
+    return function.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;
 }

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

@@ -0,0 +1,71 @@
+/*
+ * 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.protocol.dimension;
+
+import lombok.experimental.UtilityClass;
+import net.kyori.adventure.nbt.BinaryTag;
+import net.kyori.adventure.nbt.BinaryTagIO;
+import net.kyori.adventure.nbt.CompoundBinaryTag;
+import net.kyori.adventure.nbt.ListBinaryTag;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+
+import java.io.InputStream;
+import java.util.Objects;
+
+@UtilityClass
+public final class DimensionRegistry {
+  public final DimensionInfo DEFAULT_DIMENSION_1_16;
+  public final DimensionInfo DEFAULT_DIMENSION_1_18_2;
+
+  public final @NotNull CompoundBinaryTag CODEC_1_16;
+  public final @NotNull CompoundBinaryTag CODEC_1_18_2;
+  public final @NotNull CompoundBinaryTag CODEC_1_19;
+  public final @NotNull CompoundBinaryTag CODEC_1_19_1;
+  public final @NotNull CompoundBinaryTag CODEC_1_19_4;
+  public final @NotNull CompoundBinaryTag CODEC_1_20;
+  public final @NotNull CompoundBinaryTag OLD_CODEC;
+
+  static {
+    CODEC_1_16 = getCodec("codec_1_16.nbt");
+    CODEC_1_18_2 = getCodec("codec_1_18_2.nbt");
+    CODEC_1_19 = getCodec("codec_1_19.nbt");
+    CODEC_1_19_1 = getCodec("codec_1_19_1.nbt");
+    CODEC_1_19_4 = getCodec("codec_1_19_4.nbt");
+    CODEC_1_20 = getCodec("codec_1_20.nbt");
+    OLD_CODEC = getCodec("codec_old.nbt");
+
+    DEFAULT_DIMENSION_1_16 = getDimension(CODEC_1_16);
+    DEFAULT_DIMENSION_1_18_2 = getDimension(CODEC_1_18_2);
+  }
+
+  private static @NotNull DimensionInfo getDimension(final @NotNull CompoundBinaryTag tag) {
+    final ListBinaryTag dimensions = tag.getCompound("minecraft:dimension_type").getList("value");
+    final BinaryTag elementTag = ((CompoundBinaryTag) dimensions.get(0)).get("element");
+    return new DimensionInfo("minecraft:overworld", 0, (CompoundBinaryTag) elementTag);
+  }
+
+  private @NotNull CompoundBinaryTag getCodec(final @NotNull String fileName) {
+    try (final InputStream inputStream = Sonar.class.getResourceAsStream("/codecs/" + fileName)) {
+      return BinaryTagIO.reader().read(Objects.requireNonNull(inputStream), BinaryTagIO.Compression.GZIP);
+    } catch (Throwable throwable) {
+      Sonar.get().getLogger().error("Could not load mappings for {}: {}", fileName, throwable);
+      throw new IllegalStateException(throwable);
+    }
+  }
+}

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

@@ -0,0 +1,83 @@
+/*
+ * 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.protocol.map;
+
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+
+import java.util.function.Function;
+
+@SuppressWarnings("unused")
+@RequiredArgsConstructor
+public enum ItemMapType {
+  FILLED_MAP(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) {
+      default:
+        // 1.7-1.12.2
+        return 358;
+      case MINECRAFT_1_13:
+      case MINECRAFT_1_13_1:
+        return 608;
+      case MINECRAFT_1_13_2:
+        return 613;
+      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 671;
+      case MINECRAFT_1_16:
+      case MINECRAFT_1_16_1:
+      case MINECRAFT_1_16_2:
+      case MINECRAFT_1_16_3:
+      case MINECRAFT_1_16_4:
+        return 733;
+      case MINECRAFT_1_17:
+      case MINECRAFT_1_17_1:
+      case MINECRAFT_1_18:
+      case MINECRAFT_1_18_2:
+        return 847;
+      case MINECRAFT_1_19:
+      case MINECRAFT_1_19_1:
+        return 886;
+      case MINECRAFT_1_19_3:
+        return 914;
+      case MINECRAFT_1_19_4:
+        return 937;
+      case MINECRAFT_1_20:
+      case MINECRAFT_1_20_2:
+        return 941;
+      case MINECRAFT_1_20_3:
+        return 979;
+    }
+  });
+
+  private final Function<ProtocolVersion, Integer> function;
+
+  public int getId(final @NotNull ProtocolVersion protocolVersion) {
+    return function.apply(protocolVersion);
+  }
+}

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/map/MapInfo.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,27 +15,16 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.velocity.verbose;
+package xyz.jonesdev.sonar.common.fallback.protocol.map;
 
-import com.velocitypowered.api.proxy.ProxyServer;
+import lombok.Getter;
 import lombok.RequiredArgsConstructor;
-import net.kyori.adventure.text.Component;
-import xyz.jonesdev.sonar.api.verbose.Verbose;
 
+@Getter
 @RequiredArgsConstructor
-public final class VerboseWrapper extends Verbose {
-  private final ProxyServer server;
-
-  @Override
-  public void broadcast(final String message) {
-    final Component component = Component.text(message);
-
-    synchronized (subscribers) {
-      for (final String subscriber : subscribers) {
-        server.getPlayer(subscriber).ifPresent(player -> {
-          player.sendActionBar(component);
-        });
-      }
-    }
-  }
+public final class MapInfo {
+  private final String answer;
+  private final int columns, rows;
+  private final int x, y;
+  private final byte[] buffer;
 }

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

@@ -0,0 +1,248 @@
+/*
+ * 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.protocol.map;
+
+import lombok.Getter;
+import lombok.experimental.UtilityClass;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.config.SonarConfiguration;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;
+
+import java.awt.*;
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphVector;
+import java.awt.geom.AffineTransform;
+import java.awt.image.BufferedImage;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static java.awt.Font.*;
+import static xyz.jonesdev.sonar.common.fallback.protocol.map.PreparedMapInfo.DIMENSIONS;
+
+@UtilityClass
+public class MapInfoPreparer {
+  private final Random RANDOM = new Random();
+
+  private final ExecutorService PREPARATION_SERVICE = Executors.newSingleThreadExecutor();
+
+  private final int[] FONT_STYLES = new int[]{
+    PLAIN,
+    BOLD,
+    ITALIC,
+    ITALIC | BOLD
+  };
+
+  private final int[][] COLOR_PALETTE = new int[][]{
+    new int[]{ // Blue
+      48,
+      49,
+      50,
+      51
+    },
+    new int[]{ // Orange
+      60,
+      61,
+      62,
+      63,
+    },
+    new int[]{ // Green
+      4,
+      28,
+      29,
+      30,
+    },
+    new int[]{ // Black
+      27,
+      45,
+      46,
+      47,
+    },
+    new int[]{ // Red
+      16,
+      17,
+      18,
+      19
+    }
+  };
+
+  private PreparedMapInfo[] cached;
+  @Getter
+  private int preparedCAPTCHAs;
+  private boolean currentlyPreparing;
+
+  public PreparedMapInfo getRandomCaptcha() {
+    return cached[RANDOM.nextInt(preparedCAPTCHAs)];
+  }
+
+  public void prepare() {
+    final SystemTimer timer = new SystemTimer();
+    Sonar.get().getLogger().info("Precomputing map captcha answers...");
+
+    // Make sure we're not running into concurrency issues
+    if (currentlyPreparing) {
+      Sonar.get().getLogger().warn("Did not precompute map captcha answers as another task is running.");
+      return;
+    }
+
+    // Reset all statistics
+    preparedCAPTCHAs = 0;
+    currentlyPreparing = true;
+    final SonarConfiguration.Verification.Map config = Sonar.get().getConfig().getVerification().getMap();
+    cached = null;
+    cached = new PreparedMapInfo[config.getPrecomputeAmount()];
+
+    // Prepare fonts from config
+    final String dictionary = config.getDictionary();
+    final List<String> fonts = config.getFonts();
+    if (fonts.isEmpty()) {
+      Sonar.get().getLogger().warn("No fonts found, using fallback font...");
+      fonts.add(DIALOG);
+    }
+    final String[] fontTypes = fonts.toArray(new String[0]);
+
+    // Prepare distortions values from config
+    final double distortionsFactorX = config.getDistortionsFactorX();
+    final double distortionsFactorY = config.getDistortionsFactorY();
+    final double halfDistortionsFactorX = distortionsFactorX / 2D;
+    final double halfDistortionsFactorY = distortionsFactorY / 2D;
+
+    for (int _i = 0; _i < cached.length; _i++) {
+      final int currentIndex = _i;
+      final byte[] buffer = new byte[PreparedMapInfo.SCALE];
+      PREPARATION_SERVICE.execute(() -> {
+        // Create image
+        final BufferedImage image = new BufferedImage(DIMENSIONS, DIMENSIONS, BufferedImage.TYPE_3BYTE_BGR);
+        final Graphics2D graphics = (Graphics2D) image.getGraphics();
+        try {
+          // Create random font
+          final String fontType = fontTypes[RANDOM.nextInt(fontTypes.length)];
+          final int fontStyle = FONT_STYLES[RANDOM.nextInt(FONT_STYLES.length)];
+          final int fontSize = 27
+            + (config.isRandomizeFontSize()
+            ? RANDOM.nextInt(6) - 2 : 5);
+          @SuppressWarnings("all") final Font answerFont = new Font(fontType, fontStyle, fontSize);
+          graphics.setFont(answerFont);
+
+          // Build answer to the captcha
+          final StringBuilder answerBuilder = new StringBuilder();
+          for (int _j = 0; _j < 5; _j++) {
+            answerBuilder.append(dictionary.charAt(RANDOM.nextInt(dictionary.length())));
+          }
+          final String answer = answerBuilder.toString();
+
+          // Calculate text position
+          final int stringWidth = graphics.getFontMetrics().stringWidth(answer);
+          final int halfWidth = image.getWidth() / 2;
+          final int halfHeight = image.getHeight() / 2;
+          final int spacing = 5;
+          double _x = halfWidth - stringWidth / 2f - spacing;
+          double _y = halfHeight + fontSize / 3f;
+
+          // Draw each character one by one
+          final FontRenderContext fontRenderContext = graphics.getFontRenderContext();
+          for (final char c : answer.toCharArray()) {
+            // Randomize x and y
+            if (config.isRandomizePositions()) {
+              _y += RANDOM.nextInt(8) - 4;
+            }
+
+            // Apply random distortion
+            final double distortionFactorX = RANDOM.nextDouble() * distortionsFactorX - halfDistortionsFactorX;
+            final double distortionFactorY = RANDOM.nextDouble() * distortionsFactorY - halfDistortionsFactorY;
+
+            // Create a GlyphVector for the character
+            final String character = String.valueOf(c);
+            final GlyphVector glyphVector = graphics.getFont().createGlyphVector(fontRenderContext, character);
+
+            // Apply the distortion to the GlyphVector using AffineTransform
+            final AffineTransform transform = AffineTransform.getTranslateInstance(_x, _y);
+            transform.shear(distortionFactorX, distortionFactorY);
+            final Shape distortedCharacter = glyphVector.getOutline();
+            final Shape distorted = transform.createTransformedShape(distortedCharacter);
+
+            // Draw the distorted character
+            graphics.fill(distorted);
+
+            // Update x by width
+            _x += glyphVector.getVisualBounds().getWidth() + spacing;
+          }
+
+          // TODO: Color converter
+          graphics.setColor(Color.RED);
+
+          // Draw random lines
+          for (int i = 0; i < config.getRandomLinesAmount(); i++) {
+            final int startX = RANDOM.nextInt(halfWidth);
+            final int startY = RANDOM.nextInt(halfHeight);
+            final int endX = halfWidth + RANDOM.nextInt(halfWidth);
+            final int endY = halfHeight + RANDOM.nextInt(halfHeight);
+
+            graphics.drawLine(startX, startY, endX, endY);
+          }
+
+          // Draw random ovals
+          for (int i = 0; i < config.getRandomOvalsAmount(); i++) {
+            final int startX = RANDOM.nextInt(halfWidth);
+            final int startY = RANDOM.nextInt(halfHeight);
+            final int endX = halfWidth + RANDOM.nextInt(halfWidth);
+            final int endY = halfHeight + RANDOM.nextInt(halfHeight);
+
+            graphics.drawOval(startX, startY, endX, endY);
+          }
+
+          // Select random color palette
+          final int[] colorPalette = COLOR_PALETTE[currentIndex % COLOR_PALETTE.length];
+          // Select the next color palette for geometry
+          final int[] nextColorPalette = COLOR_PALETTE[(currentIndex + 1) % COLOR_PALETTE.length];
+          // Clear background
+          Arrays.fill(buffer, (byte) 57);
+          // Color every pixel individually
+          final int spacingY = halfHeight - fontSize;
+          for (int x = spacing; x < image.getWidth() - spacing; x++) {
+            for (int y = spacingY; y < image.getHeight() - spacingY; y++) {
+              final int pixel = image.getRGB(x, y);
+              final int index = y * image.getWidth() + x;
+              if (pixel == -16777216 && RANDOM.nextInt(100) < 97) continue;
+              // Set color of pixel to random color from the palette
+              final byte color = (byte) (pixel == -16777216 ? RANDOM.nextInt(100) < 75 ? 14 :
+                RANDOM.nextInt(Byte.MAX_VALUE)
+                : pixel != -65536 ? colorPalette[RANDOM.nextInt(colorPalette.length)]
+                : nextColorPalette[RANDOM.nextInt(nextColorPalette.length)]);
+              // Write pixel color to buffer
+              buffer[index] = color;
+            }
+          }
+          // Cache buffer to map
+          cached[currentIndex] = new PreparedMapInfo(answer, image.getWidth(), image.getHeight(), buffer);
+        } finally {
+          // Dispose graphics
+          graphics.dispose();
+          // Finished?
+          if (currentIndex == cached.length - 1) {
+            Sonar.get().getLogger().info("Successfully precomputed map captcha answers in {}s!", timer);
+            currentlyPreparing = false;
+          }
+          preparedCAPTCHAs++;
+        }
+      });
+    }
+  }
+}

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

@@ -0,0 +1,65 @@
+/*
+ * 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.protocol.map;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.fallback.FallbackUser;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.MapData;
+
+import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT_1_8;
+
+@Getter
+public final class PreparedMapInfo {
+  public static final int DIMENSIONS = (int) Math.pow(2, 7);
+  public static final int SCALE = DIMENSIONS * DIMENSIONS;
+
+  private final MapInfo info;
+  private final MapData[] legacy;
+  private final MapData modern;
+
+  public PreparedMapInfo(final String answer,
+                         final int columns, final int rows,
+                         final byte @NotNull [] buffer) {
+    this.info = new MapInfo(answer, columns, rows, 0, 0, buffer);
+
+    // Prepare 1.7 map data using a grid
+    final byte[][] grid = new byte[DIMENSIONS][DIMENSIONS];
+    for (int i = 0; i < buffer.length; i++) {
+      final byte buf = buffer[i];
+      grid[i & Byte.MAX_VALUE][i >> 7] = buf;
+    }
+    this.legacy = new MapData[grid.length];
+    for (int i = 0; i < grid.length; i++) {
+      this.legacy[i] = new MapData(new MapInfo(answer, DIMENSIONS, DIMENSIONS, i, 0, grid[i]));
+    }
+
+    // Prepare 1.8+ map data
+    this.modern = new MapData(info);
+  }
+
+  public void write(final @NotNull FallbackUser<?> user) {
+    if (user.getProtocolVersion().compareTo(MINECRAFT_1_8) < 0) {
+      for (final MapData data : legacy) {
+        user.delayedWrite(data);
+      }
+    } else {
+      user.delayedWrite(modern);
+    }
+  }
+}

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/netty/DeferredByteBufHolder.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/netty/FastUUID.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