Release 2.0.26 (#269 )

Recode max accounts per IP check (#268 )
Implement max accounts per IP check on Bukkit (#266 )
2024-04-20 10:14:13 +02:00 · 2024-04-18 18:39:23 +02:00 · 2024-04-18 17:57:00 +02:00 · 2024-04-18 17:55:09 +02:00 · 2024-04-07 14:44:06 +02:00 · 2024-04-07 14:38:40 +02:00
198 changed files with 7413 additions and 4986 deletions
@@ -8,7 +8,6 @@ joining the [Discord](https://jonesdev.xyz/discord).
 2. Follow the coding guidelines for your code.
 3. Test your code before committing and pushing it.
 4. Use [semantic](https://gist.github.com/joshbuchea/6f47e86d2510bce28f8e7f42ae84c716) commit messages for your commits.
-5. Create a feature branch or push to the `dev` branch.

 ## Coding Guidelines:

@@ -25,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
@@ -33,27 +33,21 @@
 * Effective, lightweight, and easy-to-use
 * No unnecessary features and clean code
 * Protection against all kinds of bot attacks
-* No player should be annoyed by any sort of captcha
+* No player should be annoyed by any sort of [CAPTCHA](https://en.wikipedia.org/wiki/CAPTCHA)
 * No sort of checking for VPNs or proxies
-* Multi-platform support (Velocity, BungeeCord, and Bukkit)
+* Multi-platform support (See [supported versions](https://docs.jonesdev.xyz/sonar/supported-versions))

 ## Checks

- New player logins are queued to prevent spam login attacks.
- [Fallback](https://github.com/jonesdevelopment/sonar#fallback) is Sonar's main component designed to prevent
-  all types of bots.
- Spigot & BungeeCord
-  - Duplicate login/status packet spam fix
-  - Run server ping handling 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](https://github.com/jonesdevelopment/sonar#fallback) is Sonar's main anti-bot component
+- Sonar queues new player logins to prevent spam login attacks
+- Sonar checks the handshake packets for legitimacy
+- Sonar makes sure some packets cannot be duplicated illegitimately

 ### Fallback

-Fallback analyzes a player's behavior before joining the actual server, therefore stopping malicious traffic from ever
-reaching the backend.
-It is supposed to be an instant, powerful, and invisible method of verification that should prevent all typical and
-advanced types of bots.
+Fallback analyzes a player's behavior before joining the actual server, therefore stopping malicious traffic from ever reaching the backend.
+It is supposed to be an instant, powerful, and invisible method of verification that should prevent all typical and advanced types of bots.

 * Sends the player to a lightweight fake server when they connect for the first time.
 * Analyzes if the player is sending the necessary packets.
@@ -61,16 +55,11 @@ advanced types of bots.
 * Checks if the player is obeying client gravity.
 * Checks if the player is colliding with blocks correctly.

-Fallback also protects from huge spambot attacks since it queues the incoming connections, therefore making it
-technically impossible to have a ton of bots join the server at the same time.
+Fallback also protects against huge spambot attacks since it queues the incoming connections, therefore making it technically impossible to have a ton of bots join the server at the same time.

 ### False positives

-Fallback is unlikely to ever falsely prevent a player from joining the server since Minecraft uses the TCP protocol which means that packets are always sent in the correct order. Therefore, lag or ping should not affect the bot check.
-However, there are some edge cases where Fallback might not receive packets within the necessary time period. In this case, Sonar tries to account for these edge cases in order to prevent false positives. For example, some higher Minecraft versions have a bug where the client sometimes sends a packet out of order. Sonar accounts for that and does not falsely blacklist clients.
-If you or one of your players experiences a false positive, make sure to report it by opening
-a [GitHub issue](https://github.com/jonesdevelopment/sonar/issues) or a ticket
-on [Discord](https://jonesdev.xyz/discord/).
+Fallback is unlikely to ever falsely prevent a player from joining the server since Minecraft uses the TCP protocol, which means that packets are always sent in the correct order. Therefore, lag or ping should not affect the bot check. However, there are some edge cases where Fallback might not receive packets within the necessary time period. In this case, Sonar tries to account for these edge cases in order to prevent false positives. If you or one of your players experiences a false positive, make sure to report it by opening a [GitHub issue](https://github.com/jonesdevelopment/sonar/issues) or a ticket on [Discord](https://jonesdev.xyz/discord/).

 ## Building

@@ -80,9 +69,7 @@ You can also take a look at the [gradle documentation](https://docs.gradle.org/c

 ## Contributing

-If you are interested in contributing, you can check out
-the [Contributing Guidelines](https://github.com/jonesdevelopment/sonar/blob/main/.github/CONTRIBUTING.md) for detailed
-instructions.
+If you are interested in contributing, you can check out the [Contributing Guidelines](https://github.com/jonesdevelopment/sonar/blob/main/.github/CONTRIBUTING.md) for detailed instructions.

 ## License

@@ -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.
@@ -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
@@ -30,6 +30,5 @@ gradlew*
 *.jpg
 *.jpeg
 *.log
-*.yml
 *.svg
 *.txt
@@ -6,7 +6,7 @@ buildscript {

 plugins {
  id("java")
-  id("com.github.johnrengelman.shadow") version "8.1.1"
+  id("io.github.goooler.shadow") version "8.1.7"
  id("io.toolebox.git-versioner") version "1.6.7"
 }

@@ -21,86 +21,75 @@ versioner {
 allprojects {
  repositories {
    mavenCentral() // Lombok
-    maven(url = "https://jitpack.io") // simple-yaml
    maven(url = "https://repo.jonesdev.xyz/releases/") // Bungee & Velocity proxy module
+    maven(url = "https://s01.oss.sonatype.org/content/repositories/snapshots/") // libby
  }

  apply(plugin = "java")
-  apply(plugin = "com.github.johnrengelman.shadow")
+  apply(plugin = "io.github.goooler.shadow")

  dependencies {
-    compileOnly("org.projectlombok:lombok:1.18.30")
-    annotationProcessor("org.projectlombok:lombok:1.18.30")
+    compileOnly("org.projectlombok:lombok:1.18.32")
+    annotationProcessor("org.projectlombok:lombok:1.18.32")

-    testCompileOnly("org.projectlombok:lombok:1.18.30")
-    testAnnotationProcessor("org.projectlombok:lombok:1.18.30")
-
-    val adventureVersion = "4.14.0"
+    testCompileOnly("org.projectlombok:lombok:1.18.32")
+    testAnnotationProcessor("org.projectlombok:lombok:1.18.32")

    // 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("net.kyori:adventure-text-minimessage:4.16.0")
+    compileOnly("net.kyori:adventure-text-serializer-gson:4.16.0")

-    implementation("com.j256.ormlite:ormlite-jdbc:6.1") // ORM
-    implementation("xyz.jonesdev:cappuccino:0.1.6-SNAPSHOT") // expiring cache
+    compileOnly("com.j256.ormlite:ormlite-jdbc:6.1") // ORMLite
+    compileOnly("com.github.ben-manes.caffeine:caffeine:3.1.8") // caching
+    compileOnly("io.netty:netty-all:4.1.108.Final") // netty

-    compileOnly("io.netty:netty-all:4.1.101.Final") // netty
+    // Library/dependency loading
+    compileOnly("com.alessiodp.libby:libby-core:2.0.0-SNAPSHOT")
  }
-}

-dependencies {
-  sequenceOf("api", "bukkit", "bungee", "common", "velocity").forEach {
-    // We want the jar to actually contain our modules
-    implementation(project(":$it"))
+  tasks {
+    shadowJar {
+      // Set the file name of the shadowed jar
+      archiveFileName.set("${rootProject.name}-${project.name.replaceFirstChar { it.uppercase() }}.jar")
+
+      // Remove file timestamps
+      isPreserveFileTimestamps = false
+
+      // Relocate libraries
+      relocate("org.bstats", "xyz.jonesdev.sonar.libs.bstats")
+      relocate("com.alessiodp.libby", "xyz.jonesdev.sonar.libs.libby")
+      relocate("com.simpleyaml", "xyz.jonesdev.sonar.libs.yaml")
+      relocate("com.google.gson", "xyz.jonesdev.sonar.libs.gson")
+      relocate("com.j256.ormlite", "xyz.jonesdev.sonar.libs.ormlite")
+      relocate("com.github.benmanes.caffeine", "xyz.jonesdev.sonar.libs.caffeine")
+      relocate("com.mysql", "xyz.jonesdev.sonar.libs.mysql")
+      relocate("org.mariadb", "xyz.jonesdev.sonar.libs.mariadb")
+      relocate("xyz.jonesdev.capja", "xyz.jonesdev.sonar.libs.capja")
+
+      // Exclude unnecessary metadata information
+      exclude("META-INF/*/**")
+    }
+
+    compileJava {
+      options.encoding = "UTF-8"
+    }
+
+    jar {
+      manifest {
+        // Set the implementation version, so we can create exact version
+        // information in-game and make it accessible to the user.
+        attributes["Implementation-Version"] = rootProject.version
+        attributes["Implementation-Vendor"] = "Jones Development, Sonar Contributors"
+      }
+    }
  }
 }

 tasks {
-  jar {
-    manifest {
-      // Set the implementation version, so we can create exact version
-      // information in-game and make it accessible to the user.
-      attributes["Implementation-Version"] = version
-      attributes["Implementation-Vendor"] = "Jones Development, Sonar Contributors"
-    }
-  }
-
-  shadowJar {
-    // Set the file name of the shadowed jar
-    archiveFileName.set("Sonar.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("org.simpleyaml", "xyz.jonesdev.sonar.libs.yaml")
-    relocate("com.google.gson", "xyz.jonesdev.sonar.libs.gson")
-    relocate("com.j256.ormlite", "xyz.jonesdev.sonar.libs.ormlite")
-    relocate("xyz.jonesdev.cappuccino", "xyz.jonesdev.sonar.libs.cappuccino")
-    relocate("net.kyori.examination", "xyz.jonesdev.sonar.libs.examination")
-    // 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.**")
-    }
-
-    // Exclude unnecessary metadata information
-    exclude("META-INF/versions/**")
-  }
-
-  compileJava {
-    options.encoding = "UTF-8"
-  }
-
  // This is a small wrapper tasks to simplify the building process
  register("build-sonar") {
-    dependsOn(clean, shadowJar)
+    val subprojects = listOf("api", "common", "bukkit", "bungee", "velocity")
+    val buildTasks = subprojects.flatMap { listOf("$it:clean", "$it:shadowJar") }
+    dependsOn(buildTasks)
  }
 }
@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-# Fix permissions so we are actually able to run our gradle script
-chmod +x gradle*
-# You can also use clean shadowJar if something goes wrong here
-# e.g. "./gradlew clean shadowJar --stacktrace"
-./gradlew build-sonar --stacktrace
@@ -1,3 +1,3 @@
 group=xyz.jonesdev.sonar
-version=2.0.10
+version=2.0.26
 description=Effective Anti-bot plugin for Velocity, BungeeCord, and Bukkit (1.7-latest)
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
@@ -1,4 +1,4 @@
-rootProject.name = "sonar"
+rootProject.name = "Sonar"

 sequenceOf("api", "bukkit", "bungee", "common", "velocity").forEach {
  val path = "sonar-$it"
@@ -1,10 +1,14 @@
+repositories {
+  maven(url = "https://jitpack.io/") // simple-yaml
+}
+
 dependencies {
-  implementation("com.github.Carleslc.Simple-YAML:Simple-Yaml:1.8.4") {
+  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
@@ -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
@@ -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
@@ -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,9 +17,10 @@

 package xyz.jonesdev.sonar.api;

-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
+import net.kyori.adventure.audience.Audience;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.attack.AttackTracker;
 import xyz.jonesdev.sonar.api.command.subcommand.SubcommandRegistry;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
@@ -27,24 +28,36 @@ 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.statistics.SonarStatistics;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;
+import xyz.jonesdev.sonar.api.verbose.Notification;
 import xyz.jonesdev.sonar.api.verbose.Verbose;

 import java.io.File;
+import java.net.InetAddress;
 import java.text.DecimalFormat;
+import java.util.UUID;

 public interface Sonar {
  DecimalFormat DECIMAL_FORMAT = new DecimalFormat("#,###.##");
-  String LINE_SEPARATOR = "\n"; // Using System.lineSeparator is broken, for some reason...

-  Gson GENERAL_GSON = new GsonBuilder()
-    .disableInnerClassSerialization()
-    .create();
+  /**
+   * Since we want to use Adventure on every server platform,
+   * we have to use their platform module to support BungeeCord and Bukkit
+   */
+  @ApiStatus.Internal
+  @Nullable Audience audience(final @Nullable UUID uniqueId);

  /**
   * @return The platform the plugin is being run on
   */
  @NotNull SonarPlatform getPlatform();

+  /**
+   * @return If the amount of players online with the same IP address is greater than a maximum
+   */
+  boolean hasTooManyAccounts(final @NotNull InetAddress inetAddress, final int limit);
+
  /**
   * @return A small wrapper for the plugin logger so we can use the logger everywhere
   */
@@ -60,12 +73,24 @@ public interface Sonar {

  @NotNull Verbose getVerboseHandler();

+  @NotNull Notification getNotificationHandler();
+
+  @NotNull SystemTimer getLaunchTimer();
+
+  @NotNull SonarStatistics getStatistics();
+
  /**
   * Set a custom verbose handler
   */
  @SuppressWarnings("unused")
  void setVerboseHandler(final @NotNull Verbose verboseHandler);

+  /**
+   * Set a custom notification handler
+   */
+  @SuppressWarnings("unused")
+  void setNotificationHandler(final @NotNull Notification notificationHandler);
+
  /**
   * Reloads the entire plugin
   */
@@ -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
@@ -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
@@ -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
@@ -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,15 @@ 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.Statistics;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;

 import java.util.Optional;

+import static xyz.jonesdev.sonar.api.jvm.JVMProcessInformation.*;
+
@Getter
@NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class AttackTracker implements JVMProfiler {
+public final class AttackTracker {
  public static final AttackTracker INSTANCE = new AttackTracker();
  private @Nullable AttackStatistics currentAttack;
  private int attackThreshold;
@@ -42,7 +42,8 @@ public final class AttackTracker implements JVMProfiler {
  public static final class AttackStatistics {
    private final SystemTimer duration = new SystemTimer();
    private final SystemTimer timer = new SystemTimer();
-    private int peakJoinsPerSecond;
+    private long peakJoinsPerSecond;
+    private long peakConnectionsPerSecond;
    private double peakProcessCPUUsage;
    private long peakProcessMemoryUsage;
    // Calculate during-attack-statistics using their deltas
@@ -50,7 +51,7 @@ public final class AttackTracker implements JVMProfiler {
  }

  public void checkIfUnderAttack() {
-    final int joinsPerSecond = Sonar.get().getVerboseHandler().getLoginsPerSecond().estimatedSize();
+    final long joinsPerSecond = Sonar.get().getStatistics().getLoginsPerSecond();
    final int verifyingPlayers = Sonar.get().getFallback().getConnected().size();
    final int queuedPlayers = Sonar.get().getFallback().getQueue().getQueuedPlayers().size();
    final int minPlayers = Sonar.get().getConfig().getMinPlayersForAttack();
@@ -65,8 +66,9 @@ public final class AttackTracker implements JVMProfiler {
      if (currentAttack == null) {
        currentAttack = new AttackStatistics();
        currentAttack.successfulVerifications = Sonar.get().getVerifiedPlayerController().estimatedSize();
-        currentAttack.failedVerifications = Statistics.FAILED_VERIFICATIONS.get();
+        currentAttack.failedVerifications = Sonar.get().getStatistics().getTotalFailedVerifications();
        Sonar.get().getEventManager().publish(new AttackDetectedEvent());
+        Sonar.get().getNotificationHandler().sendAttackNotification();
      } else {
        // Reset attack timer if we're still under attack
        currentAttack.timer.reset();
@@ -77,6 +79,11 @@ public final class AttackTracker implements JVMProfiler {
        // Update joins per second peak if necessary
        currentAttack.peakJoinsPerSecond = joinsPerSecond;
      }
+      final long connectionsPerSecond = Sonar.get().getStatistics().getConnectionsPerSecond();
+      if (connectionsPerSecond > currentAttack.peakConnectionsPerSecond) {
+        // Update connections per second peak if necessary
+        currentAttack.peakConnectionsPerSecond = connectionsPerSecond;
+      }
      final double processCPUUsage = getProcessCPUUsage();
      if (processCPUUsage > currentAttack.peakProcessCPUUsage) {
        // Update cpu usage peak if necessary
@@ -94,39 +101,44 @@ public final class AttackTracker implements JVMProfiler {
        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 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().getBlacklisted().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("%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());
-          }));
+          Optional.ofNullable(Sonar.get().getConfig().getWebhook().getDiscordWebhook())
+            .ifPresent(webhook -> {
+              // Save attack statistics
+              final long deltaInMillis = currentAttack.duration.delay();
+              final String peakCPU = Sonar.DECIMAL_FORMAT.format(currentAttack.peakProcessCPUUsage);
+              final String peakMem = formatMemory(currentAttack.peakProcessMemoryUsage);
+              final String peakBPS = Sonar.DECIMAL_FORMAT.format(currentAttack.peakJoinsPerSecond);
+              final String peakCPS = Sonar.DECIMAL_FORMAT.format(currentAttack.peakConnectionsPerSecond);
+              final long minutes = deltaInMillis / (60 * 1000); // Convert milliseconds to minutes
+              final double seconds = (deltaInMillis % (60 * 1000)) / 1000D; // Convert remaining milliseconds to seconds
+              final String formattedDuration = String.format("%d minutes, %.0f seconds", minutes, seconds);
+              final String startTimestamp = String.valueOf(currentAttack.duration.getStart() / 1000L);
+              final String endTimestamp = String.valueOf(System.currentTimeMillis() / 1000L);
+              final long blacklisted = Sonar.get().getFallback().getBlacklist().estimatedSize();
+              // Calculate during-attack-statistics using their deltas
+              final long totalVerified = Sonar.get().getVerifiedPlayerController().estimatedSize();
+              final long verified = Math.max(totalVerified - currentAttack.successfulVerifications, 0);
+              final long totalFailed = Sonar.get().getStatistics().getTotalFailedVerifications();
+              final long failed = Math.max(totalFailed - currentAttack.failedVerifications, 0);
+
+              webhook.post(() -> {
+                final SonarConfiguration.Webhook.Embed config = Sonar.get().getConfig().getWebhook().getEmbed();
+                final String description = config.getDescription()
+                  .replace("%start-timestamp%", startTimestamp)
+                  .replace("%end-timestamp%", endTimestamp)
+                  .replace("%duration%", formattedDuration)
+                  .replace("%peak-cpu%", peakCPU)
+                  .replace("%peak-memory%", peakMem)
+                  .replace("%peak-bps%", peakBPS)
+                  .replace("%peak-cps%", peakCPS)
+                  .replace("%total-blacklisted%", Sonar.DECIMAL_FORMAT.format(blacklisted))
+                  .replace("%total-failed%", Sonar.DECIMAL_FORMAT.format(failed))
+                  .replace("%total-success%", Sonar.DECIMAL_FORMAT.format(verified));
+                return new SonarConfiguration.Webhook.Embed(
+                  config.getTitle(), config.getTitleUrl(), description, config.getR(), config.getG(), config.getB());
+              });
+            });
        }

        // Reset the attack status
@@ -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
@@ -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,34 +23,38 @@ import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;

+import java.util.UUID;
 import java.util.function.Predicate;

@Getter
@RequiredArgsConstructor
-public abstract class InvocationSource {
-  private final String name;
+public final class InvocationSource {
+  private final UUID uuid;
  private final Audience audience;
-  private final boolean player;
  private final Predicate<String> permissionFunction;

  /**
-   * Sends an empty chat message to the command executor
+   * @return True, if {@link InvocationSource#uuid} is not null
+   * @apiNote This indicates a player as a player will always have a UUID
   */
-  public final void sendMessage() {
-    sendMessage(Component.empty());
+  public boolean isPlayer() {
+    return uuid != null;
  }

  /**
   * Sends a message to the command executor
+   *
+   * @apiNote We should probably use cached components...
+   * (See {@link InvocationSource#sendMessage(Component)})
   */
-  public final void sendMessage(final String legacy) {
+  public void sendMessage(final String legacy) {
    sendMessage(MiniMessage.miniMessage().deserialize(legacy));
  }

  /**
   * Sends a message to the command executor
   */
-  public final void sendMessage(final Component component) {
+  public void sendMessage(final Component component) {
    audience.sendMessage(component);
  }
 }
@@ -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,15 +17,17 @@

 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.minimessage.MiniMessage;
 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.command.subcommand.Subcommand;
 import xyz.jonesdev.sonar.api.command.subcommand.argument.Argument;

+import java.time.Duration;
 import java.util.*;
 import java.util.stream.Collectors;

@@ -36,7 +38,9 @@ public interface SonarCommand {

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

  List<Component> CACHED_HELP_MESSAGE = new ArrayList<>();

@@ -47,10 +51,11 @@ public interface SonarCommand {
        source.sendMessage(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(source, -1L);
+
+      COMMAND_DELAY.cleanUp(); // Clean up the cache
+
+      final long timestamp = System.currentTimeMillis();
+      final long mapTimestamp = COMMAND_DELAY.asMap().getOrDefault(source.getAudience(), -1L);

      // There were some exploits with spamming commands in the past.
      // Spamming should be prevented, especially if some heavy operations are done,
@@ -59,7 +64,6 @@ public interface SonarCommand {
        source.sendMessage(Sonar.get().getConfig().getCommands().getCommandCoolDown());

        // Format delay
-        final long timestamp = System.currentTimeMillis();
        final double left = 0.5D - (timestamp - mapTimestamp) / 1000D;

        source.sendMessage(Sonar.get().getConfig().getCommands().getCommandCoolDownLeft()
@@ -67,7 +71,7 @@ public interface SonarCommand {
        return;
      }

-      DELAY.put(source);
+      COMMAND_DELAY.put(source.getAudience(), timestamp);
    }

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

 import java.io.File;
-import java.io.IOException;
-import java.util.Arrays;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;

-import static xyz.jonesdev.sonar.api.Sonar.LINE_SEPARATOR;
+import static xyz.jonesdev.sonar.api.config.SonarConfiguration.LOGGER;

@Getter
 public final class SimpleYamlConfig {
  private final File file;
  private final YamlFile yaml;

-  private static final List<String> HEADER = Arrays.asList(
-    "",
-    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",
-    ""
-  );
-
-  public SimpleYamlConfig(final File dataFolder, final String fileName) {
-    this(new File(dataFolder, fileName + ".yml"), dataFolder);
-  }
-
-  private SimpleYamlConfig(final File file, final @NotNull File folder) {
-    if (!folder.exists() && !folder.mkdir()) {
-      throw new IllegalStateException("Could not create folder?!");
-    }
-
+  public SimpleYamlConfig(final @NotNull File file) {
    this.file = file;
    this.yaml = new YamlFile(file.getPath());
  }

-  public void save() {
-    try {
-      yaml.save();
-    } catch (IOException exception) {
-      exception.printStackTrace(System.err);
+  private void replaceConfigFile(final @NotNull URL defaultData) throws Exception {
+    try (final InputStream inputStream = defaultData.openStream()) {
+      Files.copy(inputStream, file.toPath(), StandardCopyOption.REPLACE_EXISTING);
    }
  }

-  public void load() throws Exception {
-    // https://github.com/jonesdevelopment/sonar/issues/26
-    // Only load the configuration if the file already exists
-    if (yaml.exists()) {
-      yaml.loadWithComments();
-    } else {
-      yaml.createOrLoadWithComments();
+  public void load(final @NotNull URL defaultData) throws Exception {
+    final boolean exists = yaml.exists();
+
+    // Copy the configuration from the translations
+    if (!exists) {
+      replaceConfigFile(defaultData);
    }

-    // Always load the comment format and options
-    yaml.setCommentFormat(YamlCommentFormat.DEFAULT);
-    yaml.setHeader(String.join(LINE_SEPARATOR, HEADER));
+    // Load the configuration
+    yaml.loadWithComments();
+
+    // I hate my life... but this works... somehow
+    if (exists) {
+      // First, we store all values from the current (old) config
+      final Map<String, Object> values = yaml.getValues(true);
+      // Then, we replace the old config file with the default one
+      replaceConfigFile(defaultData);
+      // Re-load the configuration
+      yaml.loadWithComments();
+      // Loop through the new values from the new configuration
+      yaml.getValues(true).forEach((path, v) -> {
+        final Object value = values.get(path);
+        // Make sure we actually need to update the value
+        if (value != null && !value.equals(v)
+          && !(v instanceof MemorySection)
+          && !(value instanceof MemorySection)) {
+          // Set the old values to the new values
+          yaml.set(path, value);
+        }
+      });
+      // Save the yaml file to ensure we keep the original values
+      yaml.save();
+    }
  }

  public void set(final String path, final Object v) {
@@ -88,33 +93,81 @@ public final class SimpleYamlConfig {
    return yaml.getInt(path, def);
  }

+  public int getInt(final String path) {
+    if (!yaml.contains(path)) {
+      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      return 0;
+    }
+    return yaml.getInt(path);
+  }
+
  public boolean getBoolean(final String path, final boolean def) {
    yaml.addDefault(path, def);
    return yaml.getBoolean(path, def);
  }

+  public boolean getBoolean(final String path) {
+    if (!yaml.contains(path)) {
+      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      return false;
+    }
+    return yaml.getBoolean(path);
+  }
+
  public String getString(final String path, final String def) {
    final Object object = getObject(path, def);
    if (object instanceof String) {
      return (String) object;
    }
-    Sonar.get().getLogger().info("[config] Migrated {} to {}", path, def);
+    LOGGER.info("[config] Migrated {} to {}", path, def);
    set(path, def);
    return def;
  }

+  public @NotNull String getString(final String path) {
+    if (!yaml.contains(path)) {
+      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      return "";
+    }
+    final Object object = getObject(path);
+    if (object instanceof String) {
+      return (String) object;
+    }
+    throw new IllegalStateException("Invalid entry " + path);
+  }
+
  public Object getObject(final String path, final Object def) {
    yaml.addDefault(path, def);
    return yaml.get(path, def);
  }

+  public Object getObject(final String path) {
+    return yaml.get(path);
+  }
+
  public List<String> getStringList(final String path, final List<String> def) {
    yaml.addDefault(path, def);
    return yaml.getStringList(path);
  }

+  public List<String> getStringList(final String path) {
+    if (!yaml.contains(path)) {
+      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      return new ArrayList<>(0);
+    }
+    return yaml.getStringList(path);
+  }
+
  public List<Integer> getIntList(final String path, final List<Integer> def) {
    yaml.addDefault(path, def);
    return yaml.getIntegerList(path);
  }
+
+  public List<Integer> getIntList(final String path) {
+    if (!yaml.contains(path)) {
+      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      return new ArrayList<>(0);
+    }
+    return yaml.getIntegerList(path);
+  }
 }
@@ -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,28 +19,52 @@ package xyz.jonesdev.sonar.api.controller;

 import com.j256.ormlite.dao.Dao;
 import com.j256.ormlite.dao.DaoManager;
+import com.j256.ormlite.jdbc.JdbcPooledConnectionSource;
 import com.j256.ormlite.stmt.QueryBuilder;
 import com.j256.ormlite.support.ConnectionSource;
 import com.j256.ormlite.table.TableUtils;
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Range;
+import org.jetbrains.annotations.Unmodifiable;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
-import xyz.jonesdev.sonar.api.dependencies.DependencyLoader;
+import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
 import xyz.jonesdev.sonar.api.model.VerifiedPlayer;

 import java.net.InetAddress;
 import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;

 public final class VerifiedPlayerController {
-  private static final Map<String, Collection<UUID>> MAP = new ConcurrentHashMap<>();
  private static final ExecutorService DB_UPDATE_SERVICE = Executors.newSingleThreadExecutor();

+  private static final LoggerWrapper LOGGER = new LoggerWrapper() {
+
+    @Override
+    public void info(final String message, final Object... args) {
+      Sonar.get().getLogger().info("[database] " + message, args);
+    }
+
+    @Override
+    public void warn(final String message, final Object... args) {
+      Sonar.get().getLogger().warn("[database] " + message, args);
+    }
+
+    @Override
+    public void error(final String message, final Object... args) {
+      Sonar.get().getLogger().error("[database] " + message, args);
+    }
+  };
+
+  private final Map<String, Collection<UUID>> cache = new ConcurrentHashMap<>(128);
  private @Nullable ConnectionSource connectionSource;
  private Dao<VerifiedPlayer, Integer> dao;
  private QueryBuilder<VerifiedPlayer, Integer> queryBuilder;
@@ -48,17 +72,24 @@ public final class VerifiedPlayerController {
  private final @NotNull SonarConfiguration.Database.Type cachedDatabaseType;

  public VerifiedPlayerController() {
+    final SonarConfiguration.Database database = Sonar.get().getConfig().getDatabase();
    // Cache selected database type, so we don't need to call Sonar.get() every time
-    cachedDatabaseType = Sonar.get().getConfig().getDatabase().getType();
+    cachedDatabaseType = database.getType();

    // Don't establish a database connection if the type is NONE
    if (cachedDatabaseType == SonarConfiguration.Database.Type.NONE) {
-      Sonar.get().getLogger().warn("Make sure to configure a database to save verified players.");
+      LOGGER.warn("Configure a database to save verified players.");
      return;
    }

-    try (final ConnectionSource connectionSource = DependencyLoader.setUpDriverAndConnect()) {
-      this.connectionSource = connectionSource;
+    // Initialize MySQL/MariaDB driver
+    database.getType().getDatabaseType().loadDriver();
+
+    try {
+      connectionSource = new JdbcPooledConnectionSource(
+        String.format(database.getType().getConnectionString(),
+          database.getHost(), database.getPort(), database.getName()),
+        database.getUsername(), database.getPassword(), database.getType().getDatabaseType());

      // Create table
      try {
@@ -72,10 +103,56 @@ public final class VerifiedPlayerController {
      dao = DaoManager.createDao(connectionSource, VerifiedPlayer.class);
      queryBuilder = dao.queryBuilder();

-      dao.queryForAll().forEach(this::_add);
-    } catch (Throwable throwable) {
-      Sonar.get().getLogger().error("Error setting up database connection: {}", throwable);
-      throwable.printStackTrace(System.err);
+      // Make sure to run the clean task and the caching task in the same thread
+      // https://github.com/jonesdevelopment/sonar/issues/150
+      DB_UPDATE_SERVICE.execute(() -> {
+        try {
+          // Make sure to clear all outdated entries first
+          clearOld(database.getMaximumAge());
+          // Add all entries from the database to the cache
+          dao.queryForAll().forEach(this::_add);
+        } catch (SQLException exception) {
+          LOGGER.error("Error initializing database: {}", exception);
+        }
+      });
+    } catch (SQLException exception) {
+      LOGGER.error("Error setting up database: {}", exception);
+    }
+  }
+
+  /**
+   * Closes the connection if instantiated
+   */
+  public void close() {
+    // The connection source will always be null if the database type is NONE.
+    if (connectionSource != null) {
+      try {
+        // Properly close the connection
+        connectionSource.close();
+      } catch (Exception exception) {
+        LOGGER.error("Error closing database: {}", exception);
+      }
+    }
+  }
+
+  /**
+   * Clear all old entries using the given timestamp.
+   */
+  private void clearOld(final @Range(from = 1, to = 365) int maximumAge) throws SQLException {
+    final long timestamp = Instant.now()
+      .minus(maximumAge, ChronoUnit.DAYS)
+      .getEpochSecond() * 1000L; // convert to ms
+
+    final List<VerifiedPlayer> oldEntries = queryBuilder.where()
+      .lt("timestamp", new Timestamp(timestamp))
+      .query();
+
+    if (oldEntries != null) {
+      for (final VerifiedPlayer player : oldEntries) {
+        dao.delete(player);
+      }
+      LOGGER.info("Removed {} database entries older than {} days.",
+        oldEntries.size(), maximumAge);
    }
  }

@@ -111,7 +188,7 @@ public final class VerifiedPlayerController {
          }
        }
      } catch (SQLException exception) {
-        Sonar.get().getLogger().error("Error trying to remove entry: {}", exception);
+        LOGGER.error("Error trying to remove entry: {}", exception);
      }
    });
  }
@@ -122,7 +199,7 @@ public final class VerifiedPlayerController {
   * @param inetAddress IP address of the player
   */
  private void _remove(final @NotNull String inetAddress) {
-    MAP.remove(inetAddress);
+    cache.remove(inetAddress);
  }

  /**
@@ -149,7 +226,7 @@ public final class VerifiedPlayerController {
      try {
        dao.create(player);
      } catch (SQLException exception) {
-        Sonar.get().getLogger().error("Error trying to add entry: {}", exception);
+        LOGGER.error("Error trying to add entry: {}", exception);
      }
    });
  }
@@ -160,24 +237,30 @@ public final class VerifiedPlayerController {
   * @param player VerifiedPlayer model
   */
  private void _add(final @NotNull VerifiedPlayer player) {
-    MAP.computeIfAbsent(player.getInetAddress(), v -> new Vector<>())
+    cache.computeIfAbsent(player.getInetAddress(), v -> new ArrayList<>())
      .add(player.getPlayerUUID());
  }

  /**
+   * Returns the amount of verified IP addresses
+   *
   * @return Estimated size of the local cache
   */
  public synchronized int estimatedSize() {
-    return MAP.values().stream()
-      .mapToInt(Collection::size)
-      .sum();
+    /*
+     * TODO: Work on this
+     * return MAP.values().stream()
+     *   .mapToInt(Collection::size)
+     *   .sum();
+     */
+    return cache.size();
  }

  /**
   * @return List of UUIDs associated with one IP address
   */
-  public Collection<UUID> getUUIDs(final @NotNull String inetAddress) {
-    return MAP.getOrDefault(inetAddress, Collections.emptyList());
+  public @Unmodifiable Collection<UUID> getUUIDs(final @NotNull String inetAddress) {
+    return cache.getOrDefault(inetAddress, Collections.emptyList());
  }

  /**
@@ -186,14 +269,14 @@ public final class VerifiedPlayerController {
   */
  public void clearAll() {
    try {
-      MAP.clear();
+      cache.clear();

      // Only update the column if the database type is not NONE
      if (cachedDatabaseType != SonarConfiguration.Database.Type.NONE) {
        dao.deleteBuilder().delete();
      }
    } catch (SQLException exception) {
-      Sonar.get().getLogger().error("Error trying to clear entries: {}", exception);
+      LOGGER.error("Error trying to clear entries: {}", exception);
    }
  }

@@ -203,7 +286,7 @@ public final class VerifiedPlayerController {
   * @return Whether the local cache contains the IP and UUID
   */
  public boolean has(final @NotNull String inetAddress, final @NotNull UUID uuid) {
-    final Collection<UUID> got = MAP.get(inetAddress);
+    final Collection<UUID> got = cache.get(inetAddress);
    if (got != null) {
      return got.contains(uuid);
    }
@@ -225,15 +308,6 @@ public final class VerifiedPlayerController {
   * @return Whether the local cache contains the IP
   */
  public boolean has(final @NotNull String inetAddress) {
-    return MAP.containsKey(inetAddress);
-  }
-
-  /**
-   * @param inetAddress IP address
-   * @return Whether the local cache contains the IP
-   * @see #has(String)
-   */
-  public boolean has(final @NotNull InetAddress inetAddress) {
-    return has(inetAddress.toString());
+    return cache.containsKey(inetAddress);
  }
 }
@@ -1,90 +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.2.0"
-  ),
-  // TODO: MariaDB still seems to have some issues; investigate!
-  // https://mvnrepository.com/artifact/org.mariadb.jdbc/mariadb-java-client
-  MARIADB(
-    "org/mariadb/jdbc",
-    "mariadb-java-client",
-    "3.1.4"
-  );
-
-  private final Path tempFilePath;
-  private 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();
-  }
-}
@@ -1,81 +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.SonarPlatform;
-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.Database database = Sonar.get().getConfig().getDatabase();
-
-    final ClassLoader currentClassLoader = DependencyLoader.class.getClassLoader();
-    ClassLoader classLoader = currentClassLoader;
-
-    // Velocity doesn't include the JDBC driver, which is why we need to load it manually
-    if (Sonar.get().getPlatform() == SonarPlatform.VELOCITY) {
-      final URL url = database.getType().getDependency().getClassLoaderURL();
-
-      final Method addPath = currentClassLoader.getClass().getDeclaredMethod("addPath", Path.class);
-      addPath.setAccessible(true);
-      addPath.invoke(currentClassLoader, new File(url.toURI()).toPath());
-
-      classLoader = new ExternalClassLoader(new URL[]{url});
-    }
-
-    final String jdbcURL = String.format("jdbc:%s://%s:%d/%s",
-      database.getType().name().toLowerCase(), database.getUrl(), database.getPort(), database.getName());
-
-    final Connection connection = connect(classLoader, jdbcURL, database);
-    return new JdbcSingleConnectionSource(jdbcURL, connection);
-  }
-
-  // Mostly taken from
-  // https://github.com/Elytrium/LimboAuth/blob/master/src/main/java/net/elytrium/limboauth/dependencies/DatabaseLibrary.java#L137
-  private Connection connect(final @NotNull ClassLoader classLoader,
-                             final @NotNull String databaseURL,
-                             final @NotNull SonarConfiguration.Database database) throws Throwable {
-    final Class<?> driverClass = classLoader.loadClass(database.getType().getDriverClassName());
-    final Object driver = driverClass.getDeclaredConstructor().newInstance();
-
-    DriverManager.registerDriver((Driver) driver);
-
-    final Properties properties = new Properties();
-    properties.put("user", database.getUsername());
-    properties.put("password", database.getPassword());
-
-    final Method connect = driverClass.getDeclaredMethod("connect", String.class, Properties.class);
-    connect.setAccessible(true);
-    return (Connection) connect.invoke(driver, databaseURL, properties);
-  }
-}
@@ -1,38 +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 java.net.URL;
-import java.net.URLClassLoader;
-
-final class ExternalClassLoader extends URLClassLoader {
-
-  /**
-   * Create a URLClassLoader with the system ClassLoader as parent
-   *
-   * @param url URL for of the local file
-   */
-  public ExternalClassLoader(final URL[] url) {
-    super(url, ClassLoader.getSystemClassLoader().getParent());
-  }
-
-  // Register this URLClassLoader as parallel capable
-  static {
-    ClassLoader.registerAsParallelCapable();
-  }
-}
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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;
 }
@@ -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,17 @@ 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 org.jetbrains.annotations.NotNull;
 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;
-  @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
-  private final Optional<String> reason;
-
-  public UserVerifyFailedEvent(final FallbackUser<?, ?> user, final @Nullable String reason) {
-    this.user = user;
-    this.reason = Optional.ofNullable(reason);
-  }
+  private final @NotNull FallbackUser user;
+  private final @NotNull String reason;
 }
@@ -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;
 }
@@ -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;
 }
@@ -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;

+import com.github.benmanes.caffeine.cache.Cache;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-import lombok.val;
+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;
@@ -32,7 +31,6 @@ 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)
@@ -40,10 +38,14 @@ public final class Fallback {
  public static final Fallback INSTANCE = new Fallback();
  private static final @NotNull Sonar SONAR = Objects.requireNonNull(Sonar.get());

+  // 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);
-  // Only block the player for a few minutes to avoid issues
-  private final ExpiringCache<InetAddress> blacklisted = Cappuccino.buildExpiring(
-    10L, TimeUnit.MINUTES, 5000L);
+  // 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;

@@ -67,7 +69,18 @@ public final class Fallback {

  @SuppressWarnings("BooleanMethodIsAlwaysInverted")
  public boolean shouldVerifyNewPlayers() {
-    val timing = Sonar.get().getConfig().getVerification().getTiming();
+    return shouldPerform(Sonar.get().getConfig().getVerification().getTiming());
+  }
+
+  public boolean shouldPerformCaptcha() {
+    return shouldPerform(Sonar.get().getConfig().getVerification().getMap().getTiming());
+  }
+
+  public boolean shouldPerformVehicleCheck() {
+    return shouldPerform(Sonar.get().getConfig().getVerification().getVehicle().getTiming());
+  }
+
+  private static boolean shouldPerform(final SonarConfiguration.Verification.Timing timing) {
    return timing == SonarConfiguration.Verification.Timing.ALWAYS
      || (timing == SonarConfiguration.Verification.Timing.DURING_ATTACK
      && Sonar.get().getAttackTracker().isCurrentlyUnderAttack());
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -21,6 +21,5 @@ public interface FallbackPipelines {
  String FALLBACK_HANDLER = "sonar-fallback-handler";
  String FALLBACK_PACKET_ENCODER = "sonar-fallback-encoder";
  String FALLBACK_PACKET_DECODER = "sonar-fallback-decoder";
-  String FALLBACK_IN_TRAFFIC = "sonar-traffic-in";
-  String FALLBACK_OUT_TRAFFIC = "sonar-traffic-out";
+  String FALLBACK_BANDWIDTH = "sonar-fallback-bandwidth";
 }
@@ -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,26 +30,11 @@ 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);

-  /**
-   * @param inetAddress IP address of the player
-   * @param runnable    Queued action on the netty thread
-   * @see #remove
-   */
-  public void queue(final InetAddress inetAddress, final Runnable runnable) {
-    queuedPlayers.put(inetAddress, runnable);
-  }
-
-  /**
-   * @param inetAddress IP address of the player
-   */
-  public void remove(final InetAddress inetAddress) {
-    queuedPlayers.remove(inetAddress);
-  }
-
-  public void poll() {
+  // Runnable task executed for polling the queue
+  private final Runnable pollTask = () -> {
    final int maxQueuePolls = Sonar.get().getConfig().getQueue().getMaxQueuePolls();
    int index = 0;

@@ -71,5 +56,21 @@ public final class FallbackQueue {
    Sonar.get().getAttackTracker().checkIfUnderAttack();
    // Clean up the cache of rate-limited IPs
    Sonar.get().getFallback().getRatelimiter().cleanUpCache();
+  };
+
+  /**
+   * @param inetAddress IP address of the player
+   * @param runnable    Queued action on the netty thread
+   * @see #remove
+   */
+  public void queue(final InetAddress inetAddress, final Runnable runnable) {
+    queuedPlayers.put(inetAddress, runnable);
+  }
+
+  /**
+   * @param inetAddress IP address of the player
+   */
+  public void remove(final InetAddress inetAddress) {
+    queuedPlayers.remove(inetAddress);
  }
 }
@@ -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,23 @@

 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.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> attemptCache;
+  @Getter
+  private Cache<InetAddress, Integer> failCountCache;

  /**
   * We don't want to clean up the cache in the
@@ -37,7 +41,8 @@ public final class FallbackRatelimiter {
   * it would take up too many resources.
   */
  public void cleanUpCache() {
-    expiringCache.cleanUp(false);
+    attemptCache.cleanUp();
+    failCountCache.cleanUp();
  }

  /**
@@ -49,12 +54,27 @@ public final class FallbackRatelimiter {
  @SuppressWarnings("BooleanMethodIsAlwaysInverted")
  public boolean attempt(final @NotNull InetAddress inetAddress) {
    // Cache the IP address if it's not already cached
-    if (!expiringCache.has(inetAddress)) {
+    if (!attemptCache.asMap().containsKey(inetAddress)) {
      // Cache the IP address
-      expiringCache.put(inetAddress);
+      attemptCache.put(inetAddress, (byte) 0);
      return true;
    }
    // Deny the connection attempt
    return false;
  }
+
+  /**
+   * Checks if the player is failing verifications too often
+   * Increments the number of times this user has failed the verification
+   *
+   * @param inetAddress IP address of the player
+   * @param count       Count of previously failed verifications
+   */
+  public void incrementFails(final @NotNull InetAddress inetAddress, final int count) {
+    // Make sure to remove the old values from the cache
+    if (count > 0) {
+      failCountCache.invalidate(inetAddress);
+    }
+    failCountCache.put(inetAddress, count + 1);
+  }
 }
@@ -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,69 +18,73 @@
 package xyz.jonesdev.sonar.api.fallback;

 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.ApiStatus;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import xyz.jonesdev.cappuccino.Cappuccino;
-import xyz.jonesdev.cappuccino.ExpiringCache;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.event.impl.UserBlacklistedEvent;
-import xyz.jonesdev.sonar.api.event.impl.UserVerifyFailedEvent;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
-import xyz.jonesdev.sonar.api.statistics.Statistics;

 import java.net.InetAddress;
-import java.util.concurrent.TimeUnit;
-
-public interface FallbackUser<X, Y> {
-  @NotNull Fallback getFallback();
-
-  @NotNull X getPlayer();
-
-  @NotNull Y getConnection();
+import java.util.UUID;

+public interface FallbackUser {
  @NotNull Channel getChannel();

-  @NotNull ChannelPipeline getPipeline();
-
  @NotNull InetAddress getInetAddress();

  @NotNull ProtocolVersion getProtocolVersion();

-  /**
-   * Kicks the player from the server with
-   * the given disconnect message.
-   *
-   * @param reason Legacy disconnect message string
-   * @see #disconnect(Component)
-   */
-  default void disconnect(final @NotNull String reason) {
-    disconnect(Component.text(reason));
-  }
+  @NotNull FallbackUserState getState();
+
+  void setState(final FallbackUserState state);

  /**
-   * Kicks the player from the server with
-   * the given disconnect message.
+   * Disconnect the player during/after verification
+   * using our custom Disconnect packet.
   *
   * @param reason Disconnect message component
   */
+  @ApiStatus.Internal
  void disconnect(final @NotNull Component reason);

+  /**
+   * Takes over the channel and begins the verification process
+   *
+   * @param username Username of the player
+   * @param uuid     UUID of the player
+   * @param encoder  Name of the encoder pipeline
+   * @param decoder  Name of the decoder pipeline
+   * @param timeout  Name of the read timeout pipeline
+   * @param boss     Name of the main pipeline
+   */
+  void hijack(final @NotNull String username, final @NotNull UUID uuid,
+              final @NotNull String encoder, final @NotNull String decoder,
+              final @NotNull String timeout, final @NotNull String boss);
+
  /**
   * Sends a packet/message to the player
   *
   * @param msg Message to send to the player
   */
-  void write(final @NotNull Object msg);
+  default void write(final @NotNull Object msg) {
+    if (getChannel().isActive()) {
+      getChannel().writeAndFlush(msg, getChannel().voidPromise());
+    } else {
+      ReferenceCountUtil.release(msg);
+    }
+  }

  /**
   * Queues a buffered message that will be
   * sent once all messages are flushed.
   */
-  void delayedWrite(final @NotNull Object msg);
-
-  ExpiringCache<String> PREVIOUS_FAILS = Cappuccino.buildExpiring(3L, TimeUnit.MINUTES);
+  default void delayedWrite(final @NotNull Object msg) {
+    if (getChannel().isActive()) {
+      getChannel().write(msg, getChannel().voidPromise());
+    } else {
+      ReferenceCountUtil.release(msg);
+    }
+  }

  /**
   * Disconnects the player who failed the verification
@@ -89,39 +93,8 @@ public interface FallbackUser<X, Y> {
   * the player will be temporarily denied from verifying.
   *
   * @param reason Reason for failing the verification
+   * @apiNote The {@link xyz.jonesdev.sonar.api.event.impl.UserVerifyFailedEvent}
+   * will not be thrown if no reason is given
   */
-  default void fail(final @Nullable String reason) {
-    if (getChannel().isActive()) {
-      disconnect(Sonar.get().getConfig().getVerification().getVerificationFailed());
-
-      if (reason != null) {
-        getFallback().getLogger().info(Sonar.get().getConfig().getVerification().getFailedLog()
-          .replace("%ip%", Sonar.get().getConfig().formatAddress(getInetAddress()))
-          .replace("%protocol%", String.valueOf(getProtocolVersion().getProtocol()))
-          .replace("%reason%", reason));
-      }
-    }
-
-    Statistics.FAILED_VERIFICATIONS.increment();
-
-    // Call the VerifyFailedEvent for external API usage
-    Sonar.get().getEventManager().publish(new UserVerifyFailedEvent(this, reason));
-
-    // Make sure old entries are removed
-    PREVIOUS_FAILS.cleanUp();
-
-    // Check if the player has too many failed attempts
-    if (PREVIOUS_FAILS.has(getInetAddress().toString())) {
-      // Call the BotBlacklistedEvent for external API usage
-      Sonar.get().getEventManager().publish(new UserBlacklistedEvent(this));
-
-      getFallback().getBlacklisted().put(getInetAddress());
-      getFallback().getLogger().info(Sonar.get().getConfig().getVerification().getBlacklistLog()
-        .replace("%ip%", Sonar.get().getConfig().formatAddress(getInetAddress()))
-        .replace("%protocol%", String.valueOf(getProtocolVersion().getProtocol())));
-    } else {
-      // Cache the InetAddress for 3 minutes
-      PREVIOUS_FAILS.put(getInetAddress().toString());
-    }
-  }
+  void fail(final @NotNull String reason);
 }
@@ -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,16 +15,27 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-package xyz.jonesdev.sonar.common.fallback.protocol.map;
+package xyz.jonesdev.sonar.api.fallback;

-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+public enum FallbackUserState {
+  // 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,
+  // Vehicle check
+  VEHICLE,
+  // CAPTCHA
+  CAPTCHA,
+  // Done
+  SUCCESS,
+  // Placeholder
+  FAILED;

-@Getter
-@RequiredArgsConstructor
-public final class MapInfo {
-  private final String answer;
-  private final int columns, rows;
-  private final int x, y;
-  private final byte[] buffer;
+  public boolean canReceivePackets() {
+    return this != FAILED && this != SUCCESS;
+  }
 }
@@ -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,13 +20,15 @@ package xyz.jonesdev.sonar.api.fallback.protocol;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;

-import java.util.*;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;

@Getter
@RequiredArgsConstructor
 public enum ProtocolVersion {
  UNKNOWN(-1),
-  LEGACY(-2),
  MINECRAFT_1_7_2(4),
  MINECRAFT_1_7_6(5),
  MINECRAFT_1_8(47),
@@ -70,10 +72,8 @@ public enum ProtocolVersion {

  private final int protocol;

-  public static final ProtocolVersion MINIMUM_VERSION = MINECRAFT_1_7_2;
  public static final ProtocolVersion LATEST_VERSION;
  public static final Map<Integer, ProtocolVersion> ID_TO_PROTOCOL_CONSTANT;
-  public static final Set<ProtocolVersion> SUPPORTED_VERSIONS;

  static {
    {
@@ -90,12 +90,11 @@ public enum ProtocolVersion {
      final Set<ProtocolVersion> versions = EnumSet.noneOf(ProtocolVersion.class);

      for (final ProtocolVersion value : values()) {
-        if (!value.isUnknown() && !value.isLegacy()) {
+        if (!value.isUnknown()) {
          versions.add(value);
        }
      }

-      SUPPORTED_VERSIONS = Collections.unmodifiableSet(versions);
      LATEST_VERSION = (ProtocolVersion) versions.toArray()[versions.size() - 1];
    }
  }
@@ -111,9 +110,4 @@ public enum ProtocolVersion {
  public boolean isUnknown() {
    return this == UNKNOWN;
  }
-
-  @SuppressWarnings("BooleanMethodIsAlwaysInverted")
-  public boolean isLegacy() {
-    return this == LEGACY;
-  }
 }
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.jvm;
+
+import com.sun.management.OperatingSystemMXBean;
+import lombok.experimental.UtilityClass;
+
+import java.lang.management.ManagementFactory;
+
+@UtilityClass
+public class JVMProcessInformation {
+  private final Runtime RUNTIME = Runtime.getRuntime();
+  private final OperatingSystemMXBean MX = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
+  private final char[] MEMORY_UNITS = {'K', 'M', 'G', 'T', 'P', 'E'};
+
+  public String formatMemory(final long size) {
+    if (size < 1024L) {
+      return size + " B";
+    }
+    // https://stackoverflow.com/questions/3758606/how-can-i-convert-byte-size-into-a-human-readable-format-in-java
+    final int group = (63 - Long.numberOfLeadingZeros(size)) / 10;
+    final double formattedSize = (double) size / (1L << (group * 10));
+    final char unit = MEMORY_UNITS[group - 1];
+    // https://en.wikipedia.org/wiki/Byte#Multiple-byte_units
+    return String.format("%.1f %siB", formattedSize, unit);
+  }
+
+  /**
+   * @return Number of available processors for the JVM
+   */
+  public int getVirtualCores() {
+    return RUNTIME.availableProcessors();
+  }
+
+  /**
+   * @return Current process CPU usage in percent
+   */
+  public double getProcessCPUUsage() {
+    return MX.getProcessCpuLoad() * 100;
+  }
+
+  /**
+   * @return Current per-core process CPU usage in percent
+   */
+  public double getAverageProcessCPUUsage() {
+    return getProcessCPUUsage() / getVirtualCores();
+  }
+
+  /**
+   * @return Current system CPU usage in percent
+   */
+  public double getSystemCPUUsage() {
+    return MX.getSystemCpuLoad() * 100;
+  }
+
+  /**
+   * @return Current per-core system CPU usage in percent
+   */
+  public double getAverageSystemCPUUsage() {
+    return getSystemCPUUsage() / getVirtualCores();
+  }
+
+  /**
+   * @return Current system load average in percent
+   * @apiNote This returns the global process load, not the CPU usage
+   */
+  public double getSystemLoadAverage() {
+    return MX.getSystemLoadAverage() * 100;
+  }
+
+  /**
+   * @return Memory (in bytes) the JVM will attempt to use
+   */
+  public long getMaxMemory() {
+    return RUNTIME.maxMemory();
+  }
+
+  /**
+   * @return Memory (in bytes) available to the host machine
+   */
+  public long getTotalMemory() {
+    return RUNTIME.totalMemory();
+  }
+
+  /**
+   * @return Memory (in bytes) the JVM can allocate
+   */
+  public long getFreeMemory() {
+    return RUNTIME.freeMemory();
+  }
+
+  /**
+   * @return Memory (in bytes) the JVM is using
+   */
+  public long getUsedMemory() {
+    return getTotalMemory() - getFreeMemory();
+  }
+}
@@ -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
@@ -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
@@ -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,18 +15,20 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-package xyz.jonesdev.sonar.velocity.command;
+package xyz.jonesdev.sonar.api.ormlite;

-import com.velocitypowered.api.command.CommandSource;
-import com.velocitypowered.api.proxy.Player;
+import com.j256.ormlite.jdbc.db.MariaDbDatabaseType;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.command.InvocationSource;

-public final class VelocityInvocationSource extends InvocationSource {
-  public VelocityInvocationSource(final @NotNull CommandSource sender) {
-    super(sender instanceof Player ? ((Player) sender).getUsername() : "Console",
-      sender,
-      sender instanceof Player,
-      sender::hasPermission);
+public final class MariaDbDatabaseTypeAdapter extends MariaDbDatabaseType {
+
+  /**
+   * We need to override the default driver class name
+   * in order to use the custom relocated MariaDB driver
+   * Read more: {@link MysqlDatabaseTypeAdapter}
+   */
+  @Override
+  protected String @NotNull [] getDriverClassNames() {
+    return new String[]{"xyz.jonesdev.sonar.libs.mariadb.jdbc.Driver"};
  }
 }
@@ -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,19 +15,20 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-package xyz.jonesdev.sonar.bukkit.command;
+package xyz.jonesdev.sonar.api.ormlite;

-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
+import com.j256.ormlite.jdbc.db.MysqlDatabaseType;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.command.InvocationSource;
-import xyz.jonesdev.sonar.bukkit.SonarBukkit;

-public final class BukkitInvocationSource extends InvocationSource {
-  public BukkitInvocationSource(final @NotNull CommandSender sender) {
-    super(sender.getName(),
-      SonarBukkit.INSTANCE.getBukkitAudiences().sender(sender),
-      sender instanceof Player,
-      sender::hasPermission);
+public final class MysqlDatabaseTypeAdapter extends MysqlDatabaseType {
+
+  /**
+   * We need to override the default driver class name
+   * in order to use the custom relocated MySQL driver
+   * Read more: {@link MariaDbDatabaseTypeAdapter}
+   */
+  @Override
+  protected String @NotNull [] getDriverClassNames() {
+    return new String[]{"xyz.jonesdev.sonar.libs.mysql.cj.jdbc.Driver"};
  }
 }
@@ -1,80 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.api.profiler;
-
-import com.sun.management.OperatingSystemMXBean;
-
-import java.lang.management.ManagementFactory;
-import java.lang.management.RuntimeMXBean;
-
-public interface JVMProfiler {
-  Runtime RUNTIME = Runtime.getRuntime();
-  OperatingSystemMXBean OPERATING_SYSTEM_MX_BEAN = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
-  RuntimeMXBean RUNTIME_MX_BEAN = ManagementFactory.getRuntimeMXBean();
-  char[] MEMORY_UNITS = {'k', 'M', 'G', 'T', 'P', 'E'};
-
-  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() {
-    return RUNTIME.availableProcessors();
-  }
-
-  default double getProcessCPUUsage() {
-    return OPERATING_SYSTEM_MX_BEAN.getProcessCpuLoad() * 100;
-  }
-
-  default double getAverageProcessCPUUsage() {
-    return getProcessCPUUsage() / getVirtualCores();
-  }
-
-  default double getSystemCPUUsage() {
-    return OPERATING_SYSTEM_MX_BEAN.getSystemCpuLoad() * 100;
-  }
-
-  default double getAverageSystemCPUUsage() {
-    return getSystemCPUUsage() / getVirtualCores();
-  }
-
-  default double getSystemLoadAverage() {
-    return OPERATING_SYSTEM_MX_BEAN.getSystemLoadAverage() * 100;
-  }
-
-  default long getMaxMemory() {
-    return RUNTIME.maxMemory();
-  }
-
-  default long getTotalMemory() {
-    return RUNTIME.totalMemory();
-  }
-
-  default long getFreeMemory() {
-    return RUNTIME.freeMemory();
-  }
-
-  default long getUsedMemory() {
-    return getTotalMemory() - getFreeMemory();
-  }
-}
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.statistics;
+
+import org.jetbrains.annotations.ApiStatus;
+
+public interface SonarStatistics {
+
+  /**
+   * @return Number of connection establishments per second
+   */
+  long getConnectionsPerSecond();
+
+  /**
+   * @return Number of logins per second
+   */
+  long getLoginsPerSecond();
+
+  /**
+   * @return Currently incoming bytes per second
+   */
+  long getCurrentIncomingBandwidth();
+
+  /**
+   * @return Currently outgoing bytes per second
+   */
+  long getCurrentOutgoingBandwidth();
+
+  /**
+   * @return Total incoming bytes per second
+   */
+  long getTotalIncomingBandwidth();
+
+  /**
+   * @return Total outgoing bytes per second
+   */
+  long getTotalOutgoingBandwidth();
+
+  /**
+   * @return Same as {@link SonarStatistics#getCurrentIncomingBandwidth} but formatted
+   */
+  String getCurrentIncomingBandwidthFormatted();
+
+  /**
+   * @return Same as {@link SonarStatistics#getCurrentOutgoingBandwidth} but formatted
+   */
+  String getCurrentOutgoingBandwidthFormatted();
+
+  /**
+   * @return Same as {@link SonarStatistics#getTotalIncomingBandwidth} but formatted
+   */
+  String getTotalIncomingBandwidthFormatted();
+
+  /**
+   * @return Same as {@link SonarStatistics#getTotalOutgoingBandwidth} but formatted
+   */
+  String getTotalOutgoingBandwidthFormatted();
+
+  /**
+   * @return Total number of players who logged into the server
+   */
+  int getTotalPlayersJoined();
+
+  /**
+   * @return Total number of players who tried to verify
+   */
+  int getTotalPlayersVerified();
+
+  /**
+   * @return Total number of players who passed the verification
+   */
+  int getTotalSuccessfulVerifications();
+
+  /**
+   * @return Total number of players who failed the verification
+   */
+  int getTotalFailedVerifications();
+
+  /**
+   * @return Total number of players who passed the verification
+   */
+  long getCurrentAttemptedVerifications();
+
+  /**
+   * @return Total number of players who tried verifying
+   */
+  int getTotalAttemptedVerifications();
+
+  /**
+   * @return Current number of IP addresses that are blacklisted
+   */
+  long getCurrentBlacklistSize();
+
+  /**
+   * @return Total number of cases where an IP was blacklisted
+   * @apiNote This does not describe the current amount of blacklisted IPs
+   */
+  long getTotalBlacklistSize();
+
+  @ApiStatus.Internal
+  void cleanUpCache();
+}
@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.api.statistics;
-
-public enum Statistics {
-  TOTAL_TRAFFIC,
-  REAL_TRAFFIC,
-  FAILED_VERIFICATIONS;
-
-  private int val = -1;
-
-  /**
-   * Increments the current value by 1 with the default value of 0
-   *
-   * @see #get(int)
-   * @see #set(int)
-   */
-  public void increment() {
-    increment(0);
-  }
-
-  /**
-   * Increments the current value by 1 with a custom default value
-   *
-   * @see #get(int)
-   * @see #set(int)
-   */
-  public void increment(final int def) {
-    set(get(def) + 1);
-  }
-
-  /**
-   * @return The current value with the default value of 0
-   * @see #get(int)
-   */
-  public int get() {
-    return get(0);
-  }
-
-  /**
-   * @return The current value with a custom default value
-   */
-  public int get(final int def) {
-    return val == -1 ? def : val;
-  }
-
-  /**
-   * Set current value to a new value
-   */
-  public void set(final int value) {
-    val = value;
-  }
-}
@@ -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
@@ -32,14 +32,23 @@ public final class SystemTimer {
    start = System.currentTimeMillis();
  }

+  /**
+   * @return Time between the current timestamp and the start timestamp
+   */
  public long delay() {
    return System.currentTimeMillis() - start;
  }

+  /**
+   * @apiNote Read more: {@link SystemTimer#delay}, {@link SystemTimer#formattedDelay}
+   */
  public boolean elapsed(final long amount) {
    return delay() >= amount;
  }

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

-package xyz.jonesdev.sonar.bungee.command;
+package xyz.jonesdev.sonar.api.verbose;

-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 {
-  public BungeeInvocationSource(final @NotNull CommandSender sender) {
-    super(sender.getName(),
-      SonarBungee.INSTANCE.getBungeeAudiences().sender(sender),
-      sender instanceof ProxiedPlayer,
-      sender::hasPermission);
+import java.util.Collection;
+import java.util.UUID;
+
+public interface Observable {
+  Collection<UUID> getSubscribers();
+
+  /**
+   * @param uuid UUID of the player
+   * @return Whether the audience is subscribed or not
+   */
+  default boolean isSubscribed(final @NotNull UUID uuid) {
+    return getSubscribers().contains(uuid);
+  }
+
+  /**
+   * @param uuid UUID of the player
+   */
+  default void subscribe(final UUID uuid) {
+    getSubscribers().add(uuid);
+  }
+
+  /**
+   * @param uuid UUID of the player
+   */
+  default void unsubscribe(final UUID uuid) {
+    getSubscribers().remove(uuid);
  }
 }
@@ -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,51 +22,44 @@ 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.ApiStatus;
 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.attack.AttackTracker;
-import xyz.jonesdev.sonar.api.profiler.JVMProfiler;
-import xyz.jonesdev.sonar.api.statistics.Statistics;
+import xyz.jonesdev.sonar.api.statistics.SonarStatistics;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;

 import java.util.Collection;
-import java.util.Map;
+import java.util.UUID;
 import java.util.Vector;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.TimeUnit;

 import static xyz.jonesdev.sonar.api.Sonar.DECIMAL_FORMAT;
-import static xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter.INCOMING;
-import static xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter.OUTGOING;
+import static xyz.jonesdev.sonar.api.jvm.JVMProcessInformation.*;

@Getter
-public final class Verbose implements JVMProfiler {
-  private final @NotNull Collection<String> subscribers = new Vector<>(0);
-  private final @NotNull Map<String, Audience> audiences = new ConcurrentHashMap<>();
+public final class Verbose implements Observable {
+  private final @NotNull Collection<UUID> subscribers = new Vector<>(0);
  private int animationIndex;
-  private final ExpiringCache<Long> loginsPerSecond = Cappuccino.buildExpiring(1L, TimeUnit.SECONDS);

  // Run action bar verbose
  public void update() {
-    // Clean up all blacklisted IPs
-    Sonar.get().getFallback().getBlacklisted().cleanUp(false);
-    loginsPerSecond.cleanUp(false);
-
+    // Make sure to clean up the cached statistics
+    Sonar.get().getStatistics().cleanUpCache();
    // Don't prepare component if there are no subscribers
    if (subscribers.isEmpty()) return;
    // Prepare the action bar format component
    final Component component = prepareActionBarFormat();
    // Send the action bar to all online players
-    for (final String subscriber : subscribers) {
-      final Audience audience = audiences.get(subscriber);
+    for (final UUID subscriber : subscribers) {
+      final Audience audience = Sonar.get().audience(subscriber);
      if (audience == null) continue;
      audience.sendActionBar(component);
    }
  }

+  @ApiStatus.Internal
  public @NotNull Component prepareActionBarFormat() {
+    final SonarStatistics statistics = Sonar.get().getStatistics();
    final AttackTracker.AttackStatistics attackStatistics = Sonar.get().getAttackTracker().getCurrentAttack();
    final SystemTimer attackDuration = attackStatistics == null ? null : attackStatistics.getDuration();
    return MiniMessage.miniMessage().deserialize((attackDuration != null
@@ -76,18 +69,20 @@ public final class Verbose implements JVMProfiler {
        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(Statistics.TOTAL_TRAFFIC.get()))
-      .replace("%logins-per-second%", DECIMAL_FORMAT.format(loginsPerSecond.estimatedSize()))
-      .replace("%verify-total%", DECIMAL_FORMAT.format(Statistics.REAL_TRAFFIC.get()))
+        DECIMAL_FORMAT.format(Sonar.get().getFallback().getBlacklist().estimatedSize()))
+      .replace("%blacklisted%", DECIMAL_FORMAT.format(statistics.getCurrentBlacklistSize()))
+      .replace("%total-joins%", DECIMAL_FORMAT.format(statistics.getTotalPlayersJoined()))
+      .replace("%logins-per-second%", DECIMAL_FORMAT.format(statistics.getLoginsPerSecond()))
+      .replace("%connections-per-second%", DECIMAL_FORMAT.format(statistics.getConnectionsPerSecond()))
+      .replace("%verify-total%", DECIMAL_FORMAT.format(statistics.getTotalAttemptedVerifications()))
      .replace("%verify-success%",
        DECIMAL_FORMAT.format(Sonar.get().getVerifiedPlayerController().estimatedSize()))
-      .replace("%verify-failed%", DECIMAL_FORMAT.format(Statistics.FAILED_VERIFICATIONS.get()))
+      .replace("%verify-failed%", DECIMAL_FORMAT.format(statistics.getTotalFailedVerifications()))
      .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())
-      .replace("%outgoing-traffic-ttl%", OUTGOING.getCachedTtl())
+      .replace("%incoming-traffic%", statistics.getCurrentIncomingBandwidthFormatted())
+      .replace("%outgoing-traffic%", statistics.getCurrentOutgoingBandwidthFormatted())
+      .replace("%incoming-traffic-ttl%", statistics.getTotalIncomingBandwidthFormatted())
+      .replace("%outgoing-traffic-ttl%", statistics.getTotalOutgoingBandwidthFormatted())
      .replace("%used-memory%", formatMemory(getUsedMemory()))
      .replace("%free-memory%", formatMemory(getFreeMemory()))
      .replace("%total-memory%", formatMemory(getTotalMemory()))
@@ -100,26 +95,4 @@ public final class Verbose implements JVMProfiler {
    final int nextIndex = ++animationIndex % animations.size();
    return animations.toArray(new String[0])[nextIndex];
  }
-
-  /**
-   * @param name Name of the audience
-   * @return Whether the audience is subscribed or not
-   */
-  public boolean isSubscribed(final @NotNull String name) {
-    return subscribers.contains(name);
-  }
-
-  /**
-   * @param name Name of the audience to subscribe
-   */
-  public void subscribe(final String name) {
-    subscribers.add(name);
-  }
-
-  /**
-   * @param name Name of the audience to unsubscribe
-   */
-  public void unsubscribe(final String name) {
-    subscribers.remove(name);
-  }
 }
@@ -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,8 @@

 package xyz.jonesdev.sonar.api.webhook;

+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
 import lombok.RequiredArgsConstructor;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
@@ -32,12 +34,18 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.function.Supplier;

+import static java.net.HttpURLConnection.HTTP_NO_CONTENT;
+
@RequiredArgsConstructor
 public final class DiscordWebhook {
  private final String url;

+  private static final Gson GSON = new GsonBuilder().create();
  private static final ExecutorService HTTP_REQUEST_SERVICE = Executors.newSingleThreadExecutor();

+  /**
+   * Asynchronously posts a Discord webhook via HTTPS
+   */
  public void post(final Supplier<SonarConfiguration.Webhook.Embed> embed) {
    HTTP_REQUEST_SERVICE.execute(() -> {
      try {
@@ -47,9 +55,12 @@ public final class DiscordWebhook {
        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());
+
+        // Warn the user if the connection might've not been successful
+        // I don't know why Discord doesn't respond with OK, but I guess this should be fine
+        final int code = urlConnection.getResponseCode();
+        if (code != HTTP_NO_CONTENT) {
+          Sonar.get().getLogger().warn("Unexpected Discord webhook response code {}", code);
        }
      } catch (Exception exception) {
        Sonar.get().getLogger().error("Could not send webhook: {}", exception);
@@ -57,7 +68,7 @@ public final class DiscordWebhook {
    });
  }

-  private String prepareSerializedContent(final SonarConfiguration.Webhook.@NotNull Embed embed) {
+  private static 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();
@@ -73,7 +84,7 @@ public final class DiscordWebhook {
    final List<Webhook.EmbedMessage> embeds = Collections.singletonList(embedMessage);

    final Webhook webhook = new Webhook(content, username, avatarUrl, false, embeds);
-    return Sonar.GENERAL_GSON.toJson(webhook);
+    return GSON.toJson(webhook);
  }

  private @NotNull HttpsURLConnection prepareConnection(final @NotNull URL url,
@@ -7,12 +7,14 @@ plugins {
 apply(plugin = "net.minecrell.plugin-yml.bukkit")

 bukkit {
-  name = "Sonar"
+  name = rootProject.name
  version = rootProject.version.toString().split("-")[0]
  main = "xyz.jonesdev.sonar.bukkit.SonarBukkitPlugin"
  authors = listOf("Jones Development", "Sonar Contributors")
  website = "https://jonesdev.xyz/discord/"
  load = BukkitPluginDescription.PluginLoadOrder.POSTWORLD
+  softDepend = listOf("Geyser-Spigot", "floodgate", "Protocolize", "packetevents", "ProtocolLib", "ViaVersion")
+  foliaSupported = true

  commands {
    register("sonar") {
@@ -27,18 +29,35 @@ repositories {
 }

 dependencies {
-  compileOnly(project(":api"))
-  compileOnly(project(":common"))
+  implementation(project(":api"))
+  implementation(project(":common"))

-  // MiniMessage platform support
-  implementation("net.kyori:adventure-platform-bukkit:4.3.1")
+  // adventure platform support
+  implementation("net.kyori:adventure-platform-bukkit:4.3.2")
+  implementation("net.kyori:adventure-platform-api:4.3.2")
+  implementation("net.kyori:adventure-platform-facet:4.3.2")
+
+  // adventure minimessage
+  compileOnly("net.kyori:adventure-text-minimessage:4.16.0")
+  compileOnly("net.kyori:adventure-text-serializer-gson:4.16.0")
+  // adventure nbt
+  implementation("net.kyori:adventure-nbt:4.16.0")

  // 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
+tasks {
+  shadowJar {
+    relocate("net.kyori", "xyz.jonesdev.sonar.libs.kyori")
+  }
+}
+
+java.sourceCompatibility = JavaVersion.VERSION_11
+java.targetCompatibility = JavaVersion.VERSION_11
@@ -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,24 +17,34 @@

 package xyz.jonesdev.sonar.bukkit;

+import com.alessiodp.libby.BukkitLibraryManager;
 import lombok.Getter;
+import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.platform.bukkit.BukkitAudiences;
 import org.bstats.bukkit.Metrics;
+import org.bstats.charts.SimplePie;
+import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.SonarPlatform;
 import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
-import xyz.jonesdev.sonar.bukkit.audience.AudienceListener;
 import xyz.jonesdev.sonar.bukkit.command.BukkitSonarCommand;
 import xyz.jonesdev.sonar.common.boot.SonarBootstrap;
+import xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics;

+import java.net.InetAddress;
 import java.util.Objects;
+import java.util.UUID;

@Getter
 public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
  public static SonarBukkit INSTANCE;

  public SonarBukkit(final @NotNull SonarBukkitPlugin plugin) {
-    super(plugin, plugin.getDataFolder(), SonarPlatform.BUKKIT);
+    super(plugin, new BukkitLibraryManager(
+        plugin, plugin.getDataFolder().getName()),
+      plugin.getDataFolder(), SonarPlatform.BUKKIT);
    INSTANCE = this;
  }

@@ -43,6 +53,28 @@ public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
   */
  private final BukkitAudiences bukkitAudiences = BukkitAudiences.create(getPlugin());

+  @Override
+  public @Nullable Audience audience(final @Nullable UUID uniqueId) {
+    if (uniqueId == null) {
+      return null;
+    }
+    return bukkitAudiences.player(uniqueId);
+  }
+
+  @Override
+  public boolean hasTooManyAccounts(final @NotNull InetAddress inetAddress, final int limit) {
+    int count = 1;
+    for (final Player player : getPlugin().getServer().getOnlinePlayers()) {
+      // I don't know why, but Bukkit is *special*
+      if (Objects.isNull(player.getAddress())) continue;
+      // Check if the IP address of the player is equal to the IP trying to connect
+      if (!Objects.equals(player.getAddress().getAddress(), inetAddress)) continue;
+      // Increment count of duplicated accounts
+      if (++count >= limit) return true;
+    }
+    return false;
+  }
+
  /**
   * Create a wrapper for the plugin logger, so we can use it outside
   * the velocity module.
@@ -67,16 +99,38 @@ public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
    }
  };

+  private Metrics metrics;
+
  @Override
  public void enable() {
-
    // Initialize bStats.org metrics
-    new Metrics(getPlugin(), getPlatform().getMetricsId());
+    metrics = new Metrics(getPlugin(), getPlatform().getMetricsId());
+
+    // Add charts for some configuration options
+    metrics.addCustomChart(new SimplePie("verification",
+      () -> getConfig().getVerification().getTiming().getDisplayName()));
+    metrics.addCustomChart(new SimplePie("captcha",
+      () -> getConfig().getVerification().getMap().getTiming().getDisplayName()));

    // Register Sonar command
    Objects.requireNonNull(getPlugin().getCommand("sonar")).setExecutor(new BukkitSonarCommand());

-    // Register audience register listener
-    getPlugin().getServer().getPluginManager().registerEvents(new AudienceListener(), getPlugin());
+    // Register traffic service
+    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
+      CachedBandwidthStatistics::reset, 20L, 20L);
+
+    // Register queue service
+    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
+      getFallback().getQueue().getPollTask(), 10L, 10L);
+
+    // Register verbose service
+    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
+      Sonar.get().getVerboseHandler()::update, 4L, 4L);
+  }
+
+  @Override
+  public void disable() {
+    // Make sure to properly shutdown bStats metrics
+    metrics.shutdown();
  }
 }
@@ -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
@@ -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.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.LOWEST)
-  public void handle(final @NotNull PlayerJoinEvent event) {
-    final Audience audience = SonarBukkit.INSTANCE.getBukkitAudiences().player(event.getPlayer());
-    Sonar.get().getVerboseHandler().getAudiences().put(event.getPlayer().getName(), audience);
-  }
-
-  @EventHandler(priority = EventPriority.LOWEST)
-  public void handle(final @NotNull PlayerQuitEvent event) {
-    Sonar.get().getVerboseHandler().getAudiences().remove(event.getPlayer().getName());
-  }
-}
@@ -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,9 +21,11 @@ import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.command.InvocationSource;
 import xyz.jonesdev.sonar.api.command.SonarCommand;
+import xyz.jonesdev.sonar.bukkit.SonarBukkit;

 import java.util.List;

@@ -37,7 +39,10 @@ public final class BukkitSonarCommand implements CommandExecutor, TabExecutor, S
                           final String label,
                           final String[] args) {
    // Create our own invocation source wrapper to handle messages properly
-    final InvocationSource invocationSource = new BukkitInvocationSource(sender);
+    final InvocationSource invocationSource = new InvocationSource(
+      sender instanceof Player ? ((Player) sender).getUniqueId() : null,
+      SonarBukkit.INSTANCE.getBukkitAudiences().sender(sender),
+      sender::hasPermission);
    // Pass the invocation source and command arguments to our command handler
    handle(invocationSource, args);
    return true; // Valid
@@ -5,25 +5,43 @@ plugins {
 apply(plugin = "net.minecrell.plugin-yml.bungee")

 bungee {
-  name = "Sonar"
+  name = rootProject.name
  version = rootProject.version.toString().split("-")[0]
  main = "xyz.jonesdev.sonar.bungee.SonarBungeePlugin"
  author = "Jones Development, Sonar Contributors"
+  softDepends = setOf("Geyser-BungeeCord", "floodgate", "Protocolize", "ViaVersion")
 }

 dependencies {
-  compileOnly(project(":api"))
-  compileOnly(project(":common"))
+  implementation(project(":api"))
+  implementation(project(":common"))

  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")
+  // adventure platform support
+  implementation("net.kyori:adventure-platform-bungeecord:4.3.2")
+  implementation("net.kyori:adventure-platform-api:4.3.2")
+  implementation("net.kyori:adventure-platform-facet:4.3.2")
+
+  // adventure minimessage
+  compileOnly("net.kyori:adventure-text-minimessage:4.16.0")
+  compileOnly("net.kyori:adventure-text-serializer-gson:4.16.0")
+  // adventure nbt
+  implementation("net.kyori:adventure-nbt:4.16.0")

  // 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
+tasks {
+  shadowJar {
+    relocate("net.kyori", "xyz.jonesdev.sonar.libs.kyori")
+  }
+}
+
+java.sourceCompatibility = JavaVersion.VERSION_11
+java.targetCompatibility = JavaVersion.VERSION_11
@@ -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,25 +17,34 @@

 package xyz.jonesdev.sonar.bungee;

+import com.alessiodp.libby.BungeeLibraryManager;
 import lombok.Getter;
+import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.platform.bungeecord.BungeeAudiences;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
 import org.bstats.bungeecord.Metrics;
+import org.bstats.charts.SimplePie;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.SonarPlatform;
 import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
-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.fallback.FallbackInjectionHelper;
 import xyz.jonesdev.sonar.common.boot.SonarBootstrap;
+import xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics;
+
+import java.net.InetAddress;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;

@Getter
 public final class SonarBungee extends SonarBootstrap<SonarBungeePlugin> {
  public static SonarBungee INSTANCE;

  public SonarBungee(final @NotNull SonarBungeePlugin plugin) {
-    super(plugin, plugin.getDataFolder(), SonarPlatform.BUNGEE);
+    super(plugin, new BungeeLibraryManager(plugin), plugin.getDataFolder(), SonarPlatform.BUNGEE);
    INSTANCE = this;
  }

@@ -44,6 +53,27 @@ public final class SonarBungee extends SonarBootstrap<SonarBungeePlugin> {
   */
  private final BungeeAudiences bungeeAudiences = BungeeAudiences.create(getPlugin());

+  @Override
+  public @Nullable Audience audience(final @Nullable UUID uniqueId) {
+    if (uniqueId == null) {
+      return null;
+    }
+    return bungeeAudiences.player(uniqueId);
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  public boolean hasTooManyAccounts(final @NotNull InetAddress inetAddress, final int limit) {
+    int count = 1;
+    for (final ProxiedPlayer player : getPlugin().getServer().getPlayers()) {
+      // Check if the IP address of the player is equal to the IP trying to connect
+      if (!Objects.equals(player.getAddress().getAddress(), inetAddress)) continue;
+      // Increment count of duplicated accounts
+      if (++count >= limit) return true;
+    }
+    return false;
+  }
+
  /**
   * Create a wrapper for the plugin logger, so we can use it outside
   * the velocity module.
@@ -68,22 +98,41 @@ public final class SonarBungee extends SonarBootstrap<SonarBungeePlugin> {
    }
  };

+  private Metrics metrics;
+
  @Override
  public void enable() {
-
    // Initialize bStats.org metrics
-    new Metrics(getPlugin(), getPlatform().getMetricsId());
+    metrics = new Metrics(getPlugin(), getPlatform().getMetricsId());
+
+    // Add charts for some configuration options
+    metrics.addCustomChart(new SimplePie("verification",
+      () -> getConfig().getVerification().getTiming().getDisplayName()));
+    metrics.addCustomChart(new SimplePie("captcha",
+      () -> getConfig().getVerification().getMap().getTiming().getDisplayName()));

    // Register Sonar command
    getPlugin().getServer().getPluginManager().registerCommand(getPlugin(), new BungeeSonarCommand());

-    // Register Fallback listener
-    getPlugin().getServer().getPluginManager().registerListener(getPlugin(), new FallbackListener());
+    // Register traffic service
+    getPlugin().getServer().getScheduler().schedule(getPlugin(), CachedBandwidthStatistics::reset,
+      1L, 1L, TimeUnit.SECONDS);

-    // Register audience register listener
-    getPlugin().getServer().getPluginManager().registerListener(getPlugin(), new AudienceListener());
+    // Register queue service
+    getPlugin().getServer().getScheduler().schedule(getPlugin(), getFallback().getQueue().getPollTask(),
+      500L, 500L, TimeUnit.MILLISECONDS);

-    // Inject base into ProtocolUtils
-    BaseInjectionHelper.inject(ChildChannelInitializer.INSTANCE);
+    // Register verbose service
+    getPlugin().getServer().getScheduler().schedule(getPlugin(), Sonar.get().getVerboseHandler()::update,
+      200L, 200L, TimeUnit.MILLISECONDS);
+
+    // Make sure to inject into the server's connection handler
+    FallbackInjectionHelper.inject();
+  }
+
+  @Override
+  public void disable() {
+    // Make sure to properly shutdown bStats metrics
+    metrics.shutdown();
  }
 }
@@ -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
@@ -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.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.LOWEST)
-  public void handle(final @NotNull PostLoginEvent event) {
-    final Audience audience = SonarBungee.INSTANCE.getBungeeAudiences().player(event.getPlayer());
-    Sonar.get().getVerboseHandler().getAudiences().put(event.getPlayer().getName(), audience);
-  }
-
-  @EventHandler(priority = EventPriority.LOWEST)
-  public void handle(final @NotNull PlayerDisconnectEvent event) {
-    Sonar.get().getVerboseHandler().getAudiences().remove(event.getPlayer().getName());
-  }
-}
@@ -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,11 +18,13 @@
 package xyz.jonesdev.sonar.bungee.command;

 import net.md_5.bungee.api.CommandSender;
+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 org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.command.InvocationSource;
 import xyz.jonesdev.sonar.api.command.SonarCommand;
+import xyz.jonesdev.sonar.bungee.SonarBungee;

 import static java.util.Collections.emptyList;

@@ -32,10 +34,12 @@ public final class BungeeSonarCommand extends Command implements TabExecutor, So
  }

  @Override
-  @SuppressWarnings({"redundantSuppression"})
  public void execute(final @NotNull CommandSender sender, final String[] args) {
    // Create our own invocation source wrapper to handle messages properly
-    final InvocationSource invocationSource = new BungeeInvocationSource(sender);
+    final InvocationSource invocationSource = new InvocationSource(
+      sender instanceof ProxiedPlayer ? ((ProxiedPlayer) sender).getUniqueId() : null,
+      SonarBungee.INSTANCE.getBungeeAudiences().sender(sender),
+      sender::hasPermission);
    // Pass the invocation source and command arguments to our command handler
    handle(invocationSource, args);
  }
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.bungee.fallback;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.CorruptedFrameException;
+import net.md_5.bungee.netty.ChannelWrapper;
+import net.md_5.bungee.netty.HandlerBoss;
+import net.md_5.bungee.protocol.DefinedPacket;
+import net.md_5.bungee.protocol.PacketWrapper;
+import net.md_5.bungee.protocol.packet.Handshake;
+import net.md_5.bungee.protocol.packet.LoginRequest;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.ReflectiveOperationException;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.common.fallback.FallbackBandwidthHandler;
+import xyz.jonesdev.sonar.common.fallback.FallbackChannelHandlerAdapter;
+import xyz.jonesdev.sonar.common.fallback.FallbackUserWrapper;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
+import xyz.jonesdev.sonar.common.utility.geyser.GeyserUtil;
+
+import java.lang.reflect.Field;
+import java.net.InetSocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.UUID;
+
+import static net.md_5.bungee.netty.PipelineUtils.*;
+import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_BANDWIDTH;
+import static xyz.jonesdev.sonar.common.fallback.FallbackUserWrapper.customDisconnect;
+import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer.*;
+
+public final class FallbackChannelHandler extends FallbackChannelHandlerAdapter {
+
+  public FallbackChannelHandler(final @NotNull Channel channel) {
+    super(channel);
+  }
+
+  private static final Field CHANNEL_WRAPPER_FIELD;
+
+  static {
+    try {
+      CHANNEL_WRAPPER_FIELD = HandlerBoss.class.getDeclaredField("channel");
+      CHANNEL_WRAPPER_FIELD.setAccessible(true);
+    } catch (Exception exception) {
+      throw new ReflectiveOperationException(exception);
+    }
+  }
+
+  @Override
+  public void channelRead(final @NotNull ChannelHandlerContext ctx, final Object msg) throws Exception {
+    // Intercept any packets processed by BungeeCord
+    if (msg instanceof PacketWrapper) {
+      final PacketWrapper packetWrapper = (PacketWrapper) msg;
+      final DefinedPacket wrappedPacket = packetWrapper.packet;
+      // Don't handle any invalid packets
+      if (wrappedPacket != null) {
+        // Intercept any handshake packet by the client
+        if (wrappedPacket instanceof Handshake) {
+          handleHandshake((Handshake) wrappedPacket);
+        }
+        // Intercept any server login packet by the client
+        if (wrappedPacket instanceof LoginRequest) {
+          handleLogin(ctx, (LoginRequest) wrappedPacket, msg);
+          return;
+        }
+      }
+    }
+    // Make sure to let the server handle the rest
+    ctx.fireChannelRead(msg);
+  }
+
+  private void handleHandshake(final @NotNull Handshake handshake) throws Exception {
+    // Check if the player has already sent a handshake packet
+    if (protocolVersion != null) {
+      throw new CorruptedFrameException("Already sent handshake");
+    }
+    // Check if the hostname is invalid
+    if (handshake.getHost().isEmpty()) {
+      throw new CorruptedFrameException("Hostname is empty");
+    }
+    // Store the protocol version
+    protocolVersion = ProtocolVersion.fromId(handshake.getProtocolVersion());
+    // Connections from unknown protocol versions will be discarded
+    // as this is the safest way of handling unwanted connections
+    if (protocolVersion.isUnknown()) {
+      // Sonar does NOT support snapshots or unknown versions;
+      // I'll try my best to stay up-to-date!
+      throw new CorruptedFrameException("Unknown protocol");
+    }
+    // Hook the traffic listener
+    // TODO: Can we implement this in channelActive?
+    channel.pipeline().addFirst(FALLBACK_BANDWIDTH, FallbackBandwidthHandler.INSTANCE);
+  }
+
+  private void handleLogin(final @NotNull ChannelHandlerContext ctx,
+                           final @NotNull LoginRequest loginRequest,
+                           final @NotNull Object wrappedMessage) throws Exception {
+    // Check if the player has already sent a login packet
+    if (username != null) {
+      throw new CorruptedFrameException("Already logged on");
+    }
+    // Increase joins per second for the action bar verbose
+    GlobalSonarStatistics.countLogin();
+    // Store the username
+    username = loginRequest.getData();
+    // Make sure to use the potentially modified, real IP
+    final HandlerBoss handlerBoss = channel.pipeline().get(HandlerBoss.class);
+    final ChannelWrapper channelWrapper = (ChannelWrapper) CHANNEL_WRAPPER_FIELD.get(handlerBoss);
+    final InetSocketAddress socketAddress = (InetSocketAddress) channelWrapper.getRemoteAddress();
+    inetAddress = socketAddress.getAddress();
+
+    // Check the blacklist here since we cannot let the player "ghost join"
+    if (FALLBACK.getBlacklist().asMap().containsKey(inetAddress)) {
+      customDisconnect(channel, protocolVersion, blacklisted, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Don't continue the verification process if the verification is disabled
+    if (!Sonar.get().getFallback().shouldVerifyNewPlayers()) {
+      initialLogin(ctx, wrappedMessage, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Completely skip Geyser connections
+    if (GeyserUtil.isGeyserConnection(channel, socketAddress)) {
+      initialLogin(ctx, wrappedMessage, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Check if the player is already queued since we don't want bots to flood the queue
+    if (FALLBACK.getQueue().getQueuedPlayers().containsKey(inetAddress)) {
+      customDisconnect(channel, protocolVersion, alreadyQueued, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Check if Fallback is already verifying a player
+    // → is another player with the same IP address connected to Fallback?
+    if (FALLBACK.getConnected().containsKey(loginRequest.getData())
+      || FALLBACK.getConnected().containsValue(inetAddress)) {
+      customDisconnect(channel, protocolVersion, alreadyVerifying, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Check if the protocol ID of the player is not allowed to enter the server
+    if (Sonar.get().getConfig().getVerification().getBlacklistedProtocols()
+      .contains(protocolVersion.getProtocol())) {
+      customDisconnect(channel, protocolVersion, protocolBlacklisted, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Make sure we actually have to verify the player
+    final String offlineUUIDString = "OfflinePlayer:" + loginRequest.getData();
+    final UUID offlineUUID = UUID.nameUUIDFromBytes(offlineUUIDString.getBytes(StandardCharsets.UTF_8));
+    if (Sonar.get().getVerifiedPlayerController().has(inetAddress, offlineUUID)) {
+      initialLogin(ctx, wrappedMessage, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Check if the IP address is currently being rate-limited
+    if (!FALLBACK.getRatelimiter().attempt(inetAddress)) {
+      customDisconnect(channel, protocolVersion, reconnectedTooFast, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Check if the protocol ID of the player is allowed to bypass verification
+    if (Sonar.get().getConfig().getVerification().getWhitelistedProtocols()
+      .contains(protocolVersion.getProtocol())) {
+      initialLogin(ctx, wrappedMessage, PACKET_ENCODER, BOSS_HANDLER);
+      return;
+    }
+
+    // Queue the connection for further processing
+    FALLBACK.getQueue().queue(inetAddress, () -> channel.eventLoop().execute(() -> {
+      // Check if the username matches the valid name regex to prevent
+      // UTF-16 names or other types of exploits
+      if (!Sonar.get().getConfig().getVerification().getValidNameRegex()
+        .matcher(loginRequest.getData()).matches()) {
+        customDisconnect(channel, protocolVersion, invalidUsername, PACKET_ENCODER, BOSS_HANDLER);
+        return;
+      }
+
+      // Create an instance for the Fallback connection
+      user = new FallbackUserWrapper(channel, inetAddress, protocolVersion);
+      // Let the verification handler take over the channel
+      user.hijack(loginRequest.getData(), offlineUUID, PACKET_ENCODER, PACKET_DECODER, TIMEOUT_HANDLER, BOSS_HANDLER);
+    }));
+  }
+}
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.bungee.fallback;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelInitializer;
+import lombok.RequiredArgsConstructor;
+import xyz.jonesdev.sonar.api.ReflectiveOperationException;
+
+import java.lang.reflect.Method;
+
+import static net.md_5.bungee.netty.PipelineUtils.PACKET_DECODER;
+import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_HANDLER;
+
+@RequiredArgsConstructor
+public final class FallbackChannelInitializer extends ChannelInitializer<Channel> {
+  private static final Method INIT_CHANNEL_METHOD;
+
+  static {
+    try {
+      INIT_CHANNEL_METHOD = ChannelInitializer.class.getDeclaredMethod("initChannel", Channel.class);
+      INIT_CHANNEL_METHOD.setAccessible(true);
+    } catch (Throwable throwable) {
+      throw new ReflectiveOperationException(throwable);
+    }
+  }
+
+  private final ChannelInitializer<Channel> originalChannelInitializer;
+
+  @Override
+  protected void initChannel(final Channel channel) throws Exception {
+    // Invoke the original method
+    try {
+      INIT_CHANNEL_METHOD.invoke(originalChannelInitializer, channel);
+    } catch (Throwable throwable) {
+      throw new ReflectiveOperationException(throwable);
+    }
+
+    if (channel.pipeline().get(PACKET_DECODER) != null) {
+      channel.pipeline().addAfter(PACKET_DECODER, FALLBACK_HANDLER, new FallbackChannelHandler(channel));
+    }
+  }
+}
@@ -1,87 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback;
-
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.handler.codec.haproxy.HAProxyMessage;
-import net.md_5.bungee.api.ProxyServer;
-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 org.jetbrains.annotations.NotNull;
-
-public final class FallbackHandlerBoss extends HandlerBoss {
-  private ChannelWrapper channel;
-  private PacketHandler handler;
-
-  @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) {
-      channel = new ChannelWrapper(ctx);
-      super.channelActive(ctx);
-    }
-  }
-
-  @Override
-  public void channelInactive(final ChannelHandlerContext ctx) throws Exception {
-    if (handler != null) {
-      channel.markClosed();
-      super.channelInactive(ctx);
-    }
-  }
-
-  @Override
-  public void channelWritabilityChanged(final ChannelHandlerContext ctx) throws Exception {
-    if (handler != null) {
-      handler.writabilityChanged(channel);
-      super.channelWritabilityChanged(ctx);
-    }
-  }
-
-  @Override
-  public void channelRead(final ChannelHandlerContext ctx, final Object msg) throws Exception {
-    if (msg instanceof HAProxyMessage || msg instanceof PacketWrapper) {
-      super.channelRead(ctx, msg);
-    }
-  }
-
-  @Override
-  public void exceptionCaught(final @NotNull ChannelHandlerContext ctx, final Throwable throwable) throws Exception {
-    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);
-        }
-      }
-
-      channel.markClosed();
-      ctx.close();
-    }
-  }
-}
@@ -1,345 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback;
-
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelFutureListener;
-import io.netty.channel.ChannelPipeline;
-import io.netty.handler.codec.CorruptedFrameException;
-import io.netty.handler.codec.DecoderException;
-import lombok.Getter;
-import lombok.val;
-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.config.ListenerInfo;
-import net.md_5.bungee.chat.ComponentSerializer;
-import net.md_5.bungee.connection.InitialHandler;
-import net.md_5.bungee.netty.ChannelWrapper;
-import net.md_5.bungee.protocol.PlayerPublicKey;
-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.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.net.InetAddress;
-import java.nio.charset.StandardCharsets;
-import java.time.Instant;
-import java.util.Map;
-import java.util.Objects;
-import java.util.UUID;
-import java.util.concurrent.CompletableFuture;
-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 FallbackInitialHandler extends InitialHandler {
-  public FallbackInitialHandler(final @NotNull BungeeCord bungee, final ListenerInfo listener) {
-    super(bungee, listener);
-    this.bungee = bungee;
-  }
-
-  private static final @NotNull Fallback FALLBACK = Objects.requireNonNull(Sonar.get().getFallback());
-  @Getter
-  private ChannelWrapper channelWrapper;
-  private final @NotNull BungeeCord bungee;
-  private @Nullable FallbackUserWrapper user;
-  @Getter
-  private ProtocolVersion protocolVersion;
-  private boolean receivedLoginPacket;
-  private boolean receivedStatusPacket;
-
-  @Override
-  public void connected(final ChannelWrapper channelWrapper) throws Exception {
-    this.channelWrapper = channelWrapper;
-    super.connected(channelWrapper);
-  }
-
-  @Override
-  public void handle(final StatusRequest statusRequest) throws Exception {
-    // Fix status packet spam exploit
-    if (receivedStatusPacket) {
-      throw new CorruptedFrameException("Duplicate status packet");
-    }
-    receivedStatusPacket = true;
-    // Run the rest of the method asynchronously
-    CompletableFuture.runAsync(() -> {
-      // The channel always stays open because the client sends
-      // a StatusRequest and a Ping packet after one another
-      if (!isConnected()) {
-        throw new CorruptedFrameException("Not connected anymore");
-      }
-      try {
-        super.handle(statusRequest);
-      } catch (Exception exception) {
-        throw new DecoderException(exception);
-      }
-    });
-  }
-
-  @Override
-  public void handle(final LoginRequest loginRequest) throws Exception {
-    // Increase joins per second for the action bar verbose
-    Sonar.get().getVerboseHandler().getLoginsPerSecond().put(System.nanoTime());
-
-    // 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 int protocolId = getHandshake().getProtocolVersion();
-    protocolVersion = ProtocolVersion.fromId(protocolId);
-    final Channel channel = channelWrapper.getHandle();
-
-    // Run in the channel's event loop
-    channel.eventLoop().execute(() -> {
-      try {
-        final ChannelPipeline pipeline = channel.pipeline();
-        TrafficChannelHooker.hook(pipeline, PACKET_DECODER, PACKET_ENCODER);
-
-        // Increase total traffic statistic
-        Statistics.TOTAL_TRAFFIC.increment();
-
-        final InetAddress inetAddress = getAddress().getAddress();
-        // Check the blacklist here since we cannot let the player "ghost join"
-        if (FALLBACK.getBlacklisted().has(inetAddress)) {
-          closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getBlacklisted()));
-          return;
-        }
-
-        // Check if the verification is enabled
-        if (!Sonar.get().getFallback().shouldVerifyNewPlayers()) {
-          super.handle(loginRequest);
-          return;
-        }
-
-        // Completely skip Geyser connections
-        if (isGeyserConnection(channel)) {
-          FALLBACK.getLogger().info("Skipping Geyser player: {}{}",
-            loginRequest.getData(), Sonar.get().getConfig().formatAddress(inetAddress));
-          super.handle(loginRequest);
-          return;
-        }
-
-        // Check if the protocol ID of the player is not allowed to enter the server
-        if (Sonar.get().getConfig().getVerification().getBlacklistedProtocols().contains(protocolId)) {
-          closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getProtocolBlacklisted()));
-          return;
-        }
-
-        val 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.handle(loginRequest);
-          return;
-        }
-
-        // Check if the protocol ID of the player is allowed to bypass verification
-        if (Sonar.get().getConfig().getVerification().getWhitelistedProtocols().contains(protocolId)) {
-          super.handle(loginRequest);
-          return;
-        }
-
-        // Create wrapped Fallback user
-        user = new FallbackUserWrapper(
-          FALLBACK, channelWrapper, 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) {
-            disconnect(bungee.getTranslation("secure_profile_required"));
-            return;
-          }
-          if (Instant.ofEpochMilli(publicKey.getExpiry()).isBefore(Instant.now())) {
-            disconnect(bungee.getTranslation("secure_profile_expired"));
-            return;
-          }
-          if (user.getProtocolVersion().compareTo(MINECRAFT_1_19_1) < 0
-            && !EncryptionUtil.check(publicKey, null)) {
-            disconnect(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()));
-
-        // 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) {
-            disconnect(bungee.getTranslation("proxy_full"));
-            return;
-          } else if (!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);
-      }
-    });
-  }
-
-  private static final Map<Component, Kick> CACHED_KICK_PACKETS = new ConcurrentHashMap<>(10);
-
-  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;
-  }
-
-  // Mostly taken from Velocity
-  public void closeWith(final Object msg) {
-    if (channelWrapper.getHandle().isActive()) {
-      boolean is17 = protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_8) < 0
-        && protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_7_2) >= 0;
-      if (is17) {
-        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);
-      }
-    }
-  }
-}
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-package xyz.jonesdev.sonar.bungee.fallback.injection;
+package xyz.jonesdev.sonar.bungee.fallback;

 import io.netty.channel.Channel;
 import io.netty.channel.ChannelInitializer;
@@ -27,20 +27,27 @@ import xyz.jonesdev.sonar.api.ReflectiveOperationException;
 import java.lang.reflect.Field;

@UtilityClass
-public class BaseInjectionHelper {
-  public void inject(final ChannelInitializer<Channel> childHandler) {
+public class FallbackInjectionHelper {
+  public void inject() {
    try {
      final Field childField = PipelineUtils.class.getField("SERVER_CHILD");
      childField.setAccessible(true);

+      // Make sure to store the original channel initializer
+      final ChannelInitializer<Channel> originalInitializer = PipelineUtils.SERVER_CHILD;
+      final ChannelInitializer<Channel> fallbackInitializer = new FallbackChannelInitializer(originalInitializer);
+
      final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
      unsafeField.setAccessible(true);
      final Unsafe unsafe = (Unsafe) unsafeField.get(null);

+      // Get the base object (the object containing the field)
      final Object base = unsafe.staticFieldBase(childField);
+      // Get the offset of the static field within its class
      final long offset = unsafe.staticFieldOffset(childField);

-      unsafe.putObject(base, offset, childHandler);
+      // Replace the original channel initializer
+      unsafe.putObject(base, offset, fallbackInitializer);
    } catch (Exception exception) {
      throw new ReflectiveOperationException(exception);
    }
@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback;
-
-import lombok.RequiredArgsConstructor;
-import net.kyori.adventure.text.Component;
-import net.md_5.bungee.api.event.LoginEvent;
-import net.md_5.bungee.api.plugin.Listener;
-import net.md_5.bungee.event.EventHandler;
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.bungee.SonarBungee;
-
-import java.net.InetAddress;
-import java.util.Objects;
-
-@RequiredArgsConstructor
-public final class FallbackListener implements Listener {
-
-  @EventHandler
-  @SuppressWarnings("deprecation")
-  public void handle(final @NotNull LoginEvent event) {
-    final InetAddress inetAddress = event.getConnection().getAddress().getAddress();
-
-    // 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 FallbackInitialHandler fallbackInitialHandler = (FallbackInitialHandler) event.getConnection();
-        final Component component = Sonar.get().getConfig().getTooManyOnlinePerIp();
-        fallbackInitialHandler.closeWith(FallbackInitialHandler.getKickPacket(component));
-      }
-    }
-  }
-}
@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.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.common.fallback.protocol.packets.play.Disconnect;
-
-import java.net.InetAddress;
-
-@Getter
-@RequiredArgsConstructor
-public final class FallbackUserWrapper implements FallbackUser<ChannelWrapper, FallbackInitialHandler> {
-  private final Fallback fallback;
-  private final ChannelWrapper player;
-  private final FallbackInitialHandler connection;
-  private final Channel channel;
-  private final ChannelPipeline pipeline;
-  private final InetAddress inetAddress;
-  private final ProtocolVersion protocolVersion;
-
-  @Override
-  public void disconnect(final @NotNull Component reason) {
-    connection.closeWith(Disconnect.create(reason));
-  }
-
-  @Override
-  public void write(final @NotNull Object packet) {
-    if (channel.isActive()) {
-      channel.writeAndFlush(packet, channel.voidPromise());
-    } else {
-      ReferenceCountUtil.release(packet);
-    }
-  }
-
-  @Override
-  public void delayedWrite(final @NotNull Object packet) {
-    if (channel.isActive()) {
-      channel.write(packet, channel.voidPromise());
-    } else {
-      ReferenceCountUtil.release(packet);
-    }
-  }
-}
@@ -1,77 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback.injection;
-
-import io.netty.channel.*;
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
-import net.md_5.bungee.BungeeCord;
-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;
-
-import java.lang.reflect.Field;
-import java.util.concurrent.TimeUnit;
-
-import static net.md_5.bungee.netty.PipelineUtils.*;
-
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class BaseChannelInitializer extends ChannelInitializer<Channel> {
-  public static final BaseChannelInitializer INSTANCE = new BaseChannelInitializer();
-
-  private static final boolean REPLACE_VAR_INT_DECODER = !Boolean.getBoolean("sonar.do-not-replace-decoder");
-
-  // 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 frameEncoder = PipelineUtils.class.getDeclaredField("framePrepender");
-      frameEncoder.setAccessible(true);
-      FRAME_ENCODER = (Varint21LengthFieldPrepender) frameEncoder.get(null);
-    } catch (Throwable throwable) {
-      throw new ReflectiveOperationException(throwable);
-    }
-  }
-
-  // Mostly taken from BungeeCord
-  // https://github.com/SpigotMC/BungeeCord/blob/master/proxy/src/main/java/net/md_5/bungee/netty/PipelineUtils.java#L162
-  @Override
-  protected void initChannel(final @NotNull Channel channel) throws Exception {
-    try {
-      channel.config().setOption(ChannelOption.IP_TOS, 0x18);
-    } catch (ChannelException ignored) {
-    }
-
-    channel.config().setOption(ChannelOption.TCP_NODELAY, true);
-    channel.config().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));
-    channel.pipeline().addLast(FRAME_PREPENDER, FRAME_ENCODER);
-    channel.pipeline().addLast(BOSS_HANDLER, new FallbackHandlerBoss());
-  }
-}
@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback.injection;
-
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelInitializer;
-import io.netty.handler.codec.haproxy.HAProxyMessageDecoder;
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.config.ListenerInfo;
-import net.md_5.bungee.api.event.ClientConnectEvent;
-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.api.fallback.protocol.ProtocolVersion;
-import xyz.jonesdev.sonar.bungee.fallback.FallbackHandlerBoss;
-import xyz.jonesdev.sonar.bungee.fallback.FallbackInitialHandler;
-
-import java.lang.reflect.Field;
-import java.net.SocketAddress;
-
-import static net.md_5.bungee.netty.PipelineUtils.*;
-
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class ChildChannelInitializer extends ChannelInitializer<Channel> {
-  public static final ChildChannelInitializer INSTANCE = new ChildChannelInitializer();
-
-  private static final BaseChannelInitializer BASE = BaseChannelInitializer.INSTANCE;
-  private static final BungeeCord BUNGEE = BungeeCord.getInstance();
-  private static final KickStringWriter LEGACY_KICK;
-
-  static {
-    try {
-      final Field kickField = PipelineUtils.class.getDeclaredField("legacyKicker");
-      kickField.setAccessible(true);
-      LEGACY_KICK = (KickStringWriter) kickField.get(null);
-    } catch (Throwable throwable) {
-      throw new ReflectiveOperationException(throwable);
-    }
-  }
-
-  // Mostly taken from BungeeCord
-  // https://github.com/SpigotMC/BungeeCord/blob/master/proxy/src/main/java/net/md_5/bungee/netty/PipelineUtils.java
-  @Override
-  protected void initChannel(final @NotNull Channel channel) throws Exception {
-    final SocketAddress remoteAddress = channel.remoteAddress() == null ? channel.parent().localAddress()
-      : channel.remoteAddress();
-
-    if (BUNGEE.getConnectionThrottle() != null && BUNGEE.getConnectionThrottle().throttle(remoteAddress)) {
-      channel.close();
-    } else {
-      final ListenerInfo listener = channel.attr(PipelineUtils.LISTENER).get();
-
-      if (BungeeCord.getInstance().getPluginManager().callEvent(new ClientConnectEvent(remoteAddress, listener)).isCancelled()) {
-        channel.close();
-      } else {
-        try {
-          BASE.initChannel(channel);
-        } catch (Exception exception) {
-          exception.printStackTrace(System.err);
-          channel.close();
-          return;
-        }
-
-        channel.pipeline().addBefore(FRAME_DECODER, LEGACY_DECODER, new LegacyDecoder());
-        channel.pipeline().addAfter(FRAME_DECODER, PACKET_DECODER, new MinecraftDecoder(
-          Protocol.HANDSHAKE, true, ProtocolVersion.LATEST_VERSION.getProtocol()));
-        channel.pipeline().addAfter(FRAME_PREPENDER, PACKET_ENCODER, new MinecraftEncoder(
-          Protocol.HANDSHAKE, true, ProtocolVersion.LATEST_VERSION.getProtocol()));
-        channel.pipeline().addBefore(FRAME_PREPENDER, LEGACY_KICKER, LEGACY_KICK);
-        channel.pipeline().get(FallbackHandlerBoss.class).setHandler(new FallbackInitialHandler(BUNGEE, listener));
-
-        if (listener.isProxyProtocol()) {
-          channel.pipeline().addFirst(new HAProxyMessageDecoder());
-        }
-      }
-    }
-  }
-}
@@ -1,92 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback.varint;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.handler.codec.ByteToMessageDecoder;
-import io.netty.handler.codec.CorruptedFrameException;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.List;
-
-// Mostly taken from
-// https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/netty/MinecraftVarintFrameDecoder.java
-public final class Varint21FrameDecoder extends ByteToMessageDecoder {
-
-  @Override
-  protected void decode(final @NotNull ChannelHandlerContext ctx,
-                        final ByteBuf byteBuf,
-                        final List<Object> out) throws Exception {
-    if (!ctx.channel().isActive() || !byteBuf.isReadable()) {
-      // MessageToMessageDecoder always do release after decoding
-      // https://github.com/jonesdevelopment/sonar-legacy/pull/5
-      return;
-    }
-
-    final VarintByteDecoder reader = new VarintByteDecoder();
-    final int end = byteBuf.forEachByte(reader);
-
-    if (end == -1) {
-      // This is probably a good sign that the buffer was too short or empty
-      // since the ByteBuf cannot hold a proper VarInt.
-      if (reader.getResult() == VarintByteDecoder.DecoderResult.RUN_OF_ZEROES) {
-        byteBuf.clear();
-      }
-      return;
-    }
-
-    switch (reader.getResult()) {
-      case RUN_OF_ZEROES: {
-        // this will return to the point where the next varInt starts
-        byteBuf.readerIndex(end);
-        break;
-      }
-
-      case SUCCESS: {
-        final int readVarInt = reader.getReadVarInt();
-
-        if (readVarInt < 0) {
-          byteBuf.clear();
-          throw new CorruptedFrameException("Result: " + reader);
-        } else if (readVarInt == 0) {
-          // Actually, we don't want to throw an Exception if the packet is empty.
-          // The check would also false flag a lot of legit players since packets
-          // in 1.7 could sometimes be empty.
-          byteBuf.readerIndex(end + 1);
-          return;
-        }
-
-        final int bytesRead = reader.getBytesRead();
-        final int minimumRead = bytesRead + readVarInt;
-
-        if (byteBuf.isReadable(minimumRead)) {
-          out.add(byteBuf.retainedSlice(end + 1, readVarInt));
-
-          byteBuf.skipBytes(minimumRead);
-        }
-        break;
-      }
-
-      default: {
-        byteBuf.clear();
-        throw new CorruptedFrameException("Result: " + reader);
-      }
-    }
-  }
-}
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2023 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback.varint;
-
-import io.netty.util.ByteProcessor;
-import lombok.Getter;
-import lombok.ToString;
-
-// Taken from
-// https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/netty/VarintByteDecoder.java
-@Getter
-@ToString
-public final class VarintByteDecoder implements ByteProcessor {
-  private DecoderResult result = DecoderResult.TOO_SMALL;
-  private int readVarInt, bytesRead;
-
-  @Override
-  public boolean process(byte b) throws Exception {
-    if (b == 0 && bytesRead == 0) {
-      result = DecoderResult.RUN_OF_ZEROES;
-      return true;
-    }
-
-    if (result == DecoderResult.RUN_OF_ZEROES) {
-      return false;
-    }
-
-    readVarInt |= (b & 0x7F) << bytesRead++ * 7;
-
-    if (bytesRead > 3) {
-      result = DecoderResult.TOO_BIG;
-      return false;
-    }
-
-    if ((b & 0x80) != 128) {
-      result = DecoderResult.SUCCESS;
-      return false;
-    }
-    return true;
-  }
-
-  public enum DecoderResult {
-    SUCCESS,
-    TOO_SMALL,
-    TOO_BIG,
-    RUN_OF_ZEROES
-  }
-}
@@ -1,6 +1,12 @@
 dependencies {
  compileOnly(project(":api"))
+
+  // adventure nbt for packets
+  compileOnly("net.kyori:adventure-nbt:4.16.0")
+
+  // CAPTCHA image generation
+  implementation("xyz.jonesdev.capja:capja:0.1.2")
 }

-java.sourceCompatibility = JavaVersion.VERSION_1_8
-java.targetCompatibility = JavaVersion.VERSION_1_8
+java.sourceCompatibility = JavaVersion.VERSION_11
+java.targetCompatibility = JavaVersion.VERSION_11
@@ -0,0 +1,95 @@
+/*
+ * 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;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.SonarPlatform;
+
+@UtilityClass
+class LibraryLoader {
+  void loadLibraries(final @NotNull LibraryManager libraryManager) {
+    libraryManager.addMavenCentral();
+    libraryManager.addJitPack();
+    libraryManager.loadLibraries(
+      // Simple-YAML
+      Library.builder()
+        .groupId("com{}github{}Carleslc{}Simple-YAML")
+        .artifactId("Simple-Yaml")
+        .version("1.8.4")
+        .relocate("com{}simpleyaml", "xyz{}jonesdev{}sonar{}libs{}yaml")
+        .build(),
+      // Gson
+      Library.builder()
+        .groupId("com{}google{}code{}gson")
+        .artifactId("gson")
+        .version("2.10.1")
+        .relocate("com{}google{}gson", "xyz{}jonesdev{}sonar{}libs{}gson")
+        .build(),
+      // Caffeine
+      Library.builder()
+        .groupId("com.github.ben-manes.caffeine")
+        .artifactId("caffeine")
+        .version("3.1.8")
+        .relocate("com{}github{}benmanes{}caffeine", "xyz{}jonesdev{}sonar{}libs{}caffeine")
+        .build(),
+      // ORMLite
+      Library.builder()
+        .groupId("com{}j256{}ormlite")
+        .artifactId("ormlite-jdbc")
+        .version("6.1")
+        .relocate("com{}j256{}ormlite", "xyz{}jonesdev{}sonar{}libs{}ormlite")
+        .build(),
+      // MySQL driver
+      Library.builder()
+        .groupId("com{}mysql")
+        .artifactId("mysql-connector-j")
+        .version("8.3.0")
+        .relocate("com{}mysql", "xyz{}jonesdev{}sonar{}libs{}mysql")
+        .build(),
+      // MariaDB driver
+      Library.builder()
+        .groupId("org{}mariadb{}jdbc")
+        .artifactId("mariadb-java-client")
+        .version("3.3.3")
+        .relocate("org{}mariadb", "xyz{}jonesdev{}sonar{}libs{}mariadb")
+        .build()
+    );
+
+    // Only load adventure dependencies if needed
+    if (Sonar.get().getPlatform() != SonarPlatform.VELOCITY) {
+      libraryManager.loadLibraries(
+        Library.builder()
+          .groupId("net{}kyori")
+          .artifactId("adventure-text-minimessage")
+          .version("4.16.0")
+          .relocate("net{}kyori", "xyz{}jonesdev{}sonar{}libs{}kyori")
+          .build(),
+        Library.builder()
+          .groupId("net{}kyori")
+          .artifactId("adventure-text-serializer-gson")
+          .version("4.16.0")
+          .relocate("net{}kyori", "xyz{}jonesdev{}sonar{}libs{}kyori")
+          .build()
+      );
+    }
+  }
+}
@@ -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,29 +17,31 @@

 package xyz.jonesdev.sonar.common.boot;

+import com.alessiodp.libby.LibraryManager;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.j256.ormlite.logger.Level;
+import com.j256.ormlite.logger.Logger;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.cappuccino.Cappuccino;
-import xyz.jonesdev.cappuccino.ExpiringCache;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.SonarPlatform;
 import xyz.jonesdev.sonar.api.SonarSupplier;
 import xyz.jonesdev.sonar.api.command.subcommand.SubcommandRegistry;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
 import xyz.jonesdev.sonar.api.controller.VerifiedPlayerController;
-import xyz.jonesdev.sonar.api.fallback.FallbackRatelimiter;
+import xyz.jonesdev.sonar.api.statistics.SonarStatistics;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
+import xyz.jonesdev.sonar.api.verbose.Notification;
 import xyz.jonesdev.sonar.api.verbose.Verbose;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer;
-import xyz.jonesdev.sonar.common.service.ServiceRepository;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
 import xyz.jonesdev.sonar.common.subcommand.SubcommandRegistryHolder;
 import xyz.jonesdev.sonar.common.update.UpdateChecker;

 import java.io.File;
-import java.net.InetAddress;
-import java.util.concurrent.TimeUnit;
+import java.time.Duration;

@Getter
@RequiredArgsConstructor
@@ -47,26 +49,39 @@ public abstract class SonarBootstrap<T> implements Sonar {
  private T plugin;
  @Setter
  private Verbose verboseHandler;
+  @Setter
+  private Notification notificationHandler;
  private SonarConfiguration config;
  private VerifiedPlayerController verifiedPlayerController;
  private File dataDirectory;
+  private final LibraryManager libraryManager;
+  private final SonarStatistics statistics;
  private final SonarPlatform platform;
  private final SubcommandRegistry subcommandRegistry;
  private final SystemTimer launchTimer = new SystemTimer();

  public SonarBootstrap(final @NotNull T plugin,
+                        final LibraryManager libraryManager,
                        final File dataDirectory,
                        final 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;
+    // Set the plugin instance
    this.plugin = plugin;
    this.dataDirectory = dataDirectory;
    this.platform = platform;
+    // Load all libraries before anything else
+    LibraryLoader.loadLibraries(libraryManager);
+    // Load the rest of the components
+    this.statistics = new GlobalSonarStatistics();
    this.verboseHandler = new Verbose();
+    this.notificationHandler = new Notification();
    this.config = new SonarConfiguration(dataDirectory);
    this.subcommandRegistry = new SubcommandRegistryHolder();
+    // Hide unnecessary debug information
+    Logger.setGlobalLogLevel(Level.WARNING);
  }

  public final void initialize() {
@@ -86,9 +101,6 @@ public abstract class SonarBootstrap<T> implements Sonar {
    getLogger().info("Successfully initialized components in {}s!", launchTimer);
    getLogger().info("Enabling all tasks and features...");

-    // Start all service threads
-    ServiceRepository.register();
-
    try {
      // Run the per-platform initialization method
      enable();
@@ -113,30 +125,58 @@ public abstract class SonarBootstrap<T> implements Sonar {
    getConfig().load();

    // Warn player if they reloaded and changed the database type
-    if (getVerifiedPlayerController() != null
-      && getVerifiedPlayerController().getCachedDatabaseType() != getConfig().getDatabase().getType()) {
-      Sonar.get().getLogger().warn("Reloading the server after changing the database type"
-        + " is generally not recommended as it can sometimes cause data loss.");
+    if (verifiedPlayerController != null
+      && verifiedPlayerController.getCachedDatabaseType() != getConfig().getDatabase().getType()) {
+      getLogger().warn("Reloading after changing the database type is not recommended as it may cause data loss.");
    }

    // Prepare cached packets
    FallbackPreparer.prepare();

-    // Update ratelimiter
-    final ExpiringCache<InetAddress> expiringCache = Cappuccino.buildExpiring(
-      getConfig().getVerification().getReconnectDelay(), TimeUnit.MILLISECONDS, 250L);
-    FallbackRatelimiter.INSTANCE.setExpiringCache(expiringCache);
+    // Update ratelimiter caches
+    getFallback().getRatelimiter().setAttemptCache(Caffeine.newBuilder()
+      .expireAfterWrite(Duration.ofMillis(getConfig().getVerification().getReconnectDelay()))
+      .build());
+    getFallback().getRatelimiter().setFailCountCache(Caffeine.newBuilder()
+      .expireAfterWrite(Duration.ofMillis(getConfig().getVerification().getRememberTime()))
+      .build());
+
+    // Update blacklist cache
+    final long blacklistTime = getConfig().getVerification().getBlacklistTime();
+    final boolean blacklistExists = getFallback().getBlacklist() != null;
+    // Make sure the blacklist is only set when we need it to prevent data loss
+    if (!blacklistExists // Make sure we create a new cache if it doesn't exist yet
+      || getFallback().getBlacklistTime() != blacklistTime) {
+      // Create new cache with the configured blacklist time
+      getFallback().setBlacklist(Caffeine.newBuilder()
+        .expireAfterWrite(Duration.ofMillis(getConfig().getVerification().getBlacklistTime()))
+        .build());
+      // Store the new blacklist time, so we don't have to reset the blacklist every reload
+      getFallback().setBlacklistTime(blacklistTime);
+      // Warn the user about changing the expiry of the blacklist values
+      if (blacklistExists) {
+        getLogger().warn("The blacklist has been reset as the duration of entries has changed.");
+      }
+    }

    // Reinitialize database controller
+    if (verifiedPlayerController != null) {
+      // Close the old connection first
+      verifiedPlayerController.close();
+    }
    verifiedPlayerController = new VerifiedPlayerController();
  }

-  public void shutdown() {
+  public final void shutdown() {
+    // Initialize shutdown process
    getLogger().info("Starting shutdown process...");
-
-    // Shut down service threads
-    ServiceRepository.shutdown();
-
+    // Close database connection
+    verifiedPlayerController.close();
+    // Run the per-platform disable method
+    disable();
+    // Thank the user for using Sonar
    getLogger().info("Successfully shut down. Goodbye!");
  }
+
+  public abstract void disable();
 }
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+
+import static xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics.INCOMING;
+import static xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics.OUTGOING;
+
+@ChannelHandler.Sharable
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class FallbackBandwidthHandler extends ChannelDuplexHandler {
+  public static final ChannelHandler INSTANCE = new FallbackBandwidthHandler();
+
+  @Override
+  public void channelRead(final @NotNull ChannelHandlerContext ctx,
+                          final @NotNull Object msg) throws Exception {
+    // We can only get the size of a message if it's a ByteBuf
+    if (msg instanceof ByteBuf) {
+      // Increment the incoming traffic by the amount of readable bytes
+      INCOMING.increment(((ByteBuf) msg).readableBytes());
+    }
+    // Make sure to let the server handle the rest
+    ctx.fireChannelRead(msg);
+  }
+
+  @Override
+  public void write(final @NotNull ChannelHandlerContext ctx,
+                    final @NotNull Object msg,
+                    final ChannelPromise promise) throws Exception {
+    // We can only get the size of a message if it's a ByteBuf
+    if (msg instanceof ByteBuf) {
+      // Increment the outgoing traffic by the amount of readable bytes
+      OUTGOING.increment(((ByteBuf) msg).readableBytes());
+    }
+    // Make sure to let the server handle the rest
+    ctx.write(msg, promise);
+  }
+}
@@ -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.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.InetSocketAddress;
-
-@RequiredArgsConstructor
-public final class FallbackChannelHandler extends ChannelInboundHandlerAdapter {
-  private static final @NotNull Fallback FALLBACK = Sonar.get().getFallback();
-  private final @NotNull String username;
-
-  @Override
-  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(((InetSocketAddress) ctx.channel().remoteAddress()).getAddress());
-
-    ctx.fireChannelUnregistered();
-  }
-}
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.fallback.Fallback;
+import xyz.jonesdev.sonar.api.fallback.FallbackUser;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
+
+import java.net.InetAddress;
+
+import static xyz.jonesdev.sonar.common.fallback.FallbackUserWrapper.customDisconnect;
+import static xyz.jonesdev.sonar.common.fallback.FallbackUserWrapper.deject;
+
+@RequiredArgsConstructor
+public class FallbackChannelHandlerAdapter extends ChannelInboundHandlerAdapter {
+  protected final Channel channel;
+  protected @Nullable String username;
+  protected InetAddress inetAddress;
+  protected ProtocolVersion protocolVersion;
+  protected @Nullable FallbackUser user;
+
+  protected static final Fallback FALLBACK = Sonar.get().getFallback();
+
+  @Override
+  public final void channelActive(final @NotNull ChannelHandlerContext ctx) {
+    // Increase connections per second for the action bar verbose
+    GlobalSonarStatistics.countConnection();
+    // Make sure to let the server handle the rest
+    ctx.fireChannelActive();
+  }
+
+  @Override
+  public final void channelInactive(final @NotNull ChannelHandlerContext ctx) {
+    // The player can disconnect without sending the login packet first
+    if (username != null) {
+      // Remove the username from the connected players
+      FALLBACK.getConnected().remove(username);
+    }
+    // The player cannot be in the queue if the IP address is invalid
+    if (inetAddress != null) {
+      // Remove the IP address from the queue
+      FALLBACK.getQueue().remove(inetAddress);
+    }
+    // The player cannot be in the verification if the user object doesn't exist,
+    // or if the user failed/succeeded the bot verification process.
+    if (user != null && user.getState().canReceivePackets()) {
+      // Mark the verification attempt as failed
+      user.fail("disconnected during verification");
+    }
+    // Make sure to let the server handle the rest
+    ctx.fireChannelInactive();
+  }
+
+  // We can override the default exceptionCaught method since this handler
+  // will run before the connection knows that there has been an error.
+  // Additionally, this will also run after our custom decoder.
+  @Override
+  public final void exceptionCaught(final @NotNull ChannelHandlerContext ctx,
+                                    final @NotNull Throwable cause) throws Exception {
+    // Simply close the channel if we encounter any errors.
+    ctx.close();
+  }
+
+  /**
+   * Executes the maximum accounts per IP limit check before letting the player join
+   *
+   * @param ctx    Forwarded channel handler context
+   * @param packet Login packet sent by the client
+   */
+  protected void initialLogin(final @NotNull ChannelHandlerContext ctx,
+                              final @NotNull Object packet,
+                              final @NotNull String encoder,
+                              final @NotNull String boss) {
+    final int maxOnlinePerIp = Sonar.get().getConfig().getMaxOnlinePerIp();
+    // Skip the maximum online per IP check if it's disabled in the configuration
+    if (maxOnlinePerIp > 0) {
+      // Check if the number of online players using the same IP address as
+      // the connecting player is greater than the configured amount
+      if (Sonar.get().hasTooManyAccounts(inetAddress, maxOnlinePerIp)) {
+        customDisconnect(channel, protocolVersion, FallbackPreparer.tooManyOnlinePerIP, encoder, boss);
+        return;
+      }
+    }
+
+    ctx.fireChannelRead(packet);
+    // Deject the channel since we don't need it anymore
+    deject(channel.pipeline());
+  }
+}
@@ -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
@@ -0,0 +1,265 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelPipeline;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.event.impl.UserBlacklistedEvent;
+import xyz.jonesdev.sonar.api.event.impl.UserVerifyFailedEvent;
+import xyz.jonesdev.sonar.api.event.impl.UserVerifyJoinEvent;
+import xyz.jonesdev.sonar.api.fallback.FallbackUser;
+import xyz.jonesdev.sonar.api.fallback.FallbackUserState;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketDecoder;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketEncoder;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginSuccessPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.DisconnectPacket;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
+
+import java.net.InetAddress;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.*;
+
+@Getter
+@ToString(of = {"protocolVersion", "inetAddress"})
+public final class FallbackUserWrapper implements FallbackUser {
+  private final Channel channel;
+  private final ChannelPipeline pipeline;
+  private final InetAddress inetAddress;
+  private final ProtocolVersion protocolVersion;
+  @Setter
+  private FallbackUserState state = FallbackUserState.LOGIN_ACK; // 1.20.2+
+
+  public FallbackUserWrapper(final @NotNull Channel channel,
+                             final @NotNull InetAddress inetAddress,
+                             final @NotNull ProtocolVersion protocolVersion) {
+    this.channel = channel;
+    this.pipeline = channel.pipeline();
+    this.inetAddress = inetAddress;
+    this.protocolVersion = protocolVersion;
+  }
+
+  @Override
+  public void disconnect(final @NotNull Component reason) {
+    closeWith(channel, protocolVersion, DisconnectPacket.create(reason, false));
+  }
+
+  @Override
+  public void hijack(final @NotNull String username, final @NotNull UUID uuid,
+                     final @NotNull String encoder, final @NotNull String decoder,
+                     final @NotNull String timeout, final @NotNull String boss) {
+    // This rarely happens when the channel hangs, but the player is still connecting
+    // This also fixes a unique issue with TCPShield and other reverse proxies
+    if (pipeline.get(encoder) == null || pipeline.get(decoder) == null) {
+      channel.close();
+      return;
+    }
+
+    // Remove main pipeline to completely take over the channel
+    if (pipeline.get(boss) != null) {
+      pipeline.remove(boss);
+    }
+
+    // The player has joined the verification
+    GlobalSonarStatistics.totalAttemptedVerifications++;
+
+    if (Sonar.get().getConfig().getVerification().isLogConnections()) {
+      // Only log the processing message if the server isn't under attack.
+      // We let the user override this through the configuration.
+      if (!Sonar.get().getAttackTracker().isCurrentlyUnderAttack()
+        || Sonar.get().getConfig().getVerification().isLogDuringAttack()) {
+        Sonar.get().getFallback().getLogger().info(Sonar.get().getConfig().getVerification().getConnectLog()
+          .replace("%name%", username)
+          .replace("%ip%", Sonar.get().getConfig().formatAddress(inetAddress))
+          .replace("%protocol%", String.valueOf(protocolVersion.getProtocol())));
+      }
+    }
+
+    // Call the VerifyJoinEvent for external API usage
+    Sonar.get().getEventManager().publish(new UserVerifyJoinEvent(username, this));
+
+    // Mark the player as connected → verifying players
+    Sonar.get().getFallback().getConnected().put(username, inetAddress);
+
+    // Add better timeout handler to avoid known exploits or issues
+    // We also want to timeout bots quickly to avoid flooding
+    final int readTimeout = Sonar.get().getConfig().getVerification().getReadTimeout();
+    pipeline.replace(timeout, timeout, new FallbackTimeoutHandler(readTimeout, TimeUnit.MILLISECONDS));
+
+    // Replace normal encoder to allow custom packets
+    final FallbackPacketEncoder newEncoder = new FallbackPacketEncoder(protocolVersion);
+    pipeline.replace(encoder, FALLBACK_PACKET_ENCODER, newEncoder);
+
+    // Send LoginSuccess packet to make the client think they are joining the server
+    write(new LoginSuccessPacket(username, uuid));
+
+    // The LoginSuccess packet has been sent, now we can change the registry state
+    newEncoder.updateRegistry(protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_20_2) >= 0
+      ? FallbackPacketRegistry.CONFIG : FallbackPacketRegistry.GAME);
+
+    // Replace normal decoder to allow custom packets
+    pipeline.replace(decoder, FALLBACK_PACKET_DECODER,
+      new FallbackPacketDecoder(this, new FallbackVerificationHandler(this, username, uuid)));
+  }
+
+  @Override
+  public void fail(final @NotNull String reason) {
+    // Make sure to set the state to failed to drop all handlers
+    setState(FallbackUserState.FAILED);
+
+    // Only log the failed message if the server isn't currently under attack.
+    // However, we let the user override this through the configuration.
+    final boolean shouldLog = !Sonar.get().getAttackTracker().isCurrentlyUnderAttack()
+      || Sonar.get().getConfig().getVerification().isLogDuringAttack();
+
+    // Only disconnect the player and log if the channel is active
+    if (channel.isActive()) {
+      disconnect(Sonar.get().getConfig().getVerification().getVerificationFailed());
+
+      if (shouldLog) {
+        Sonar.get().getFallback().getLogger().info(Sonar.get().getConfig().getVerification().getFailedLog()
+          .replace("%ip%", Sonar.get().getConfig().formatAddress(getInetAddress()))
+          .replace("%protocol%", String.valueOf(getProtocolVersion().getProtocol()))
+          .replace("%reason%", reason));
+      }
+    }
+
+    // Increment amount of total failed verifications
+    GlobalSonarStatistics.totalFailedVerifications++;
+
+    // Call the VerifyFailedEvent for external API usage
+    Sonar.get().getEventManager().publish(new UserVerifyFailedEvent(this, reason));
+
+    // Use a label, so we can easily add more code beneath this method in the future
+    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;
+
+      // Use 1 as the default amount of fails since we haven't cached anything yet
+      final int failCount = Sonar.get().getFallback().getRatelimiter().getFailCountCache()
+        .asMap().getOrDefault(inetAddress, 1);
+
+      // Now we simply need to check if the threshold is reached
+      if (failCount < blacklistThreshold) {
+        // Make sure we increment the number of fails
+        Sonar.get().getFallback().getRatelimiter().incrementFails(inetAddress, failCount);
+        break blacklist;
+      }
+
+      // Call the BotBlacklistedEvent for external API usage
+      Sonar.get().getEventManager().publish(new UserBlacklistedEvent(this));
+
+      // Increment amount of total blacklisted players
+      GlobalSonarStatistics.totalBlacklistedPlayers++;
+
+      Sonar.get().getFallback().getBlacklist().put(getInetAddress(), (byte) 0);
+
+      if (shouldLog) {
+        Sonar.get().getFallback().getLogger().info(Sonar.get().getConfig().getVerification().getBlacklistLog()
+          .replace("%ip%", Sonar.get().getConfig().formatAddress(getInetAddress()))
+          .replace("%protocol%", String.valueOf(getProtocolVersion().getProtocol())));
+      }
+
+      // Invalidate the cached entry to ensure memory safety
+      Sonar.get().getFallback().getRatelimiter().getFailCountCache().invalidate(inetAddress);
+    }
+  }
+
+  /**
+   * @param channel         Channel to close
+   * @param protocolVersion Protocol version
+   * @param msg             Packet to close the channel with
+   */
+  public static void closeWith(final @NotNull Channel channel,
+                               final @NotNull ProtocolVersion protocolVersion,
+                               final @NotNull Object msg) {
+    if (channel.isActive()) {
+      if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_8) < 0
+        && protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_7_2) >= 0) {
+        channel.eventLoop().execute(() -> {
+          channel.config().setAutoRead(false);
+          channel.eventLoop().schedule(() -> {
+            channel.writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
+          }, 250L, TimeUnit.MILLISECONDS);
+        });
+      } else {
+        channel.writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
+      }
+    }
+  }
+
+  /**
+   * Disconnect the player before verification (during login)
+   * by replacing the encoder before running the method.
+   *
+   * @param packet          Disconnect packet
+   * @param encoder         Encoder to replace
+   * @param boss            Main pipeline to remove
+   * @param channel         Channel of the player
+   * @param protocolVersion Protocol version of the player
+   */
+  public static void customDisconnect(final @NotNull Channel channel,
+                                      final @NotNull ProtocolVersion protocolVersion,
+                                      final @NotNull FallbackPacket packet,
+                                      final @NotNull String encoder,
+                                      final @NotNull String boss) {
+    // Remove main pipeline to completely take over the channel
+    if (channel.pipeline().get(boss) != null) {
+      channel.pipeline().remove(boss);
+    }
+    final ChannelHandler currentEncoder = channel.pipeline().get(encoder);
+    // Simply close the channel if no decoder exists
+    if (currentEncoder != null) {
+      // We don't need to update the encoder if it's already present
+      if (!(currentEncoder instanceof FallbackPacketEncoder)) {
+        final FallbackPacketEncoder newEncoder = new FallbackPacketEncoder(protocolVersion);
+        channel.pipeline().replace(encoder, FALLBACK_PACKET_ENCODER, newEncoder);
+      }
+      closeWith(channel, protocolVersion, packet);
+    } else {
+      channel.close();
+    }
+  }
+
+  /**
+   * Removes Sonar's pipelines from a channel to save
+   * unnecessary RAM and CPU usage
+   *
+   * @param pipeline Pipeline object of the channel
+   */
+  public static void deject(final @NotNull ChannelPipeline pipeline) {
+    // Remove Sonar's pipelines if they exist
+    if (pipeline.get(FALLBACK_HANDLER) != null) {
+      pipeline.remove(FALLBACK_HANDLER);
+    }
+  }
+}
@@ -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,16 +26,19 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.event.impl.UserVerifySuccessEvent;
+import xyz.jonesdev.sonar.api.fallback.Fallback;
 import xyz.jonesdev.sonar.api.fallback.FallbackUser;
+import xyz.jonesdev.sonar.api.fallback.FallbackUserState;
 import xyz.jonesdev.sonar.api.model.VerifiedPlayer;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
 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.map.ItemType;
+import xyz.jonesdev.sonar.common.fallback.protocol.map.MapCaptchaInfo;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.FinishConfigurationPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginAcknowledgedPacket;
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;
+import xyz.jonesdev.sonar.common.fallback.protocol.vehicle.EntityType;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
 import xyz.jonesdev.sonar.common.utility.protocol.ProtocolUtil;

 import java.util.Objects;
@@ -43,56 +46,49 @@ import java.util.Random;
 import java.util.UUID;
 import java.util.regex.Pattern;

+import static xyz.jonesdev.sonar.api.config.SonarConfiguration.Verification.Gravity.Gamemode.CREATIVE;
 import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_PACKET_DECODER;
 import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_PACKET_ENCODER;
+import static xyz.jonesdev.sonar.api.fallback.FallbackUserState.*;
 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 static final Random RANDOM = new Random();
+  private static final Fallback FALLBACK = Sonar.get().getFallback();

-  // General
  private final SystemTimer login = new SystemTimer();
-  private final @NotNull FallbackUser<?, ?> user;
+  private final @NotNull FallbackUser user;
  private final String username;
  private final UUID playerUuid;
-  private @NotNull State state = State.LOGIN_ACK; // 1.20.2

  // Checks
  private short expectedTransactionId;
  private int expectedKeepAliveId, expectedTeleportId = -1;
-  private int tick, totalReceivedPackets, ignoredMovementTicks;
-  private double posX, posY, posZ, lastY;
+  private int tick, totalReceivedPackets;
+  private double posX, posY, posZ, lastY, spawnYPosition;
  private boolean resolvedClientBrand, resolvedClientSettings;
  private boolean listenForMovements;

-  // Map captcha
+  // CAPTCHA
  private final SystemTimer keepAlive = new SystemTimer();
  private final SystemTimer actionBar = new SystemTimer();
-  private @Nullable PreparedMapInfo captcha;
+  private @Nullable MapCaptchaInfo 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
-  }
+  // Cached options to make sure the original values don't change throughout the verification
+  private final boolean performVehicle, performCaptcha, performGravity, performCollisions;

-  public FallbackVerificationHandler(final @NotNull FallbackUser<?, ?> user,
+  public FallbackVerificationHandler(final @NotNull FallbackUser user,
                                     final @NotNull String username,
                                     final @NotNull UUID playerUuid) {
    this.user = user;
    this.username = username;
    this.playerUuid = playerUuid;
+    this.performGravity = Sonar.get().getConfig().getVerification().getGravity().isEnabled();
+    this.performCollisions = Sonar.get().getConfig().getVerification().getGravity().isCheckCollisions();
+    this.performCaptcha = FALLBACK.shouldPerformCaptcha();
+    this.performVehicle = FALLBACK.shouldPerformVehicleCheck();

    if (user.getProtocolVersion().compareTo(MINECRAFT_1_20_2) < 0) {
      // Start initializing the actual join process
@@ -102,7 +98,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener

  private void configure() {
    // Set the state to CONFIGURE to avoid false positives
-    state = State.CONFIGURE;
+    user.setState(CONFIGURE);
    // Send the necessary configuration packets to the client
    user.delayedWrite(REGISTRY_SYNC);
    user.delayedWrite(FINISH_CONFIGURATION);
@@ -121,7 +117,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
      encoder.updateRegistry(registry);
    } else {
      // Something went wrong - the decoder should not be null
-      user.getFallback().getLogger().warn("Necessary pipelines for {} not found", username);
+      FALLBACK.getLogger().warn("Necessary pipelines for {} not found", username);
      // Close the channel to prevent bypasses or other potential exploits
      user.getChannel().close();
    }
@@ -133,22 +129,22 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
      sendJoinGamePacket();
    } else {
      // Set the state to KEEP_ALIVE to avoid false positives
-      state = State.KEEP_ALIVE;
+      user.setState(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(expectedKeepAliveId));
+      user.write(new KeepAlivePacket(expectedKeepAliveId));
    }
  }

  private void sendTransaction() {
    // Set the state to TRANSACTION to avoid false positives
    // and go on with the flow of the verification.
-    state = State.TRANSACTION;
+    user.setState(TRANSACTION);
    // Generate a random transaction ID
    expectedTransactionId = (short) RANDOM.nextInt();
    // Send a transaction with the given ID
-    user.write(new Transaction(0, expectedTransactionId, false));
+    user.write(new TransactionPacket(0, expectedTransactionId, false));
  }

  private void sendJoinGamePacket() {
@@ -157,7 +153,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
      // 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;
+      user.setState(CLIENT_SETTINGS);
    }
    // Send the JoinGame packet so we can continue the verification
    user.write(joinGame);
@@ -171,14 +167,18 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
  private void sendAbilitiesAndTeleport() {
    // Set the state to TELEPORT to avoid false positives
    // and go on with the flow of the verification.
-    state = State.TELEPORT;
-    // Make sure the player is unable to fly (the player is in spectator mode)
-    user.delayedWrite(DEFAULT_ABILITIES);
+    user.setState(TELEPORT);
+    // Make sure the player is unable to fly (e.g. if the player is in creative mode)
+    if (Sonar.get().getConfig().getVerification().getGravity().getGamemode() == CREATIVE) {
+      user.delayedWrite(DEFAULT_ABILITIES);
+    }
    // Generate the current teleport ID
-    expectedTeleportId = RANDOM.nextInt(Short.MAX_VALUE);
+    expectedTeleportId = RANDOM.nextInt();
+    // Add a little randomization to the spawn y coordinate
+    spawnYPosition = dynamicSpawnYPosition + RANDOM.nextDouble(0.4);
    // Teleport the player to the spawn position
-    user.delayedWrite(new PositionLook(
-      SPAWN_X_POSITION, dynamicSpawnYPosition, SPAWN_Z_POSITION,
+    user.delayedWrite(new PlayerPositionLookPacket(
+      SPAWN_X_POSITION, spawnYPosition, SPAWN_Z_POSITION,
      0f, -90f, expectedTeleportId, false));
    // Make sure the player escapes the 1.18.2+ "Loading terrain" screen
    if (user.getProtocolVersion().compareTo(MINECRAFT_1_18_2) >= 0) {
@@ -187,9 +187,16 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
  }

  private void sendChunkData() {
+    // If we don't have any checks, simply finish verification
+    // This is *hopefully* a very rare case though...
+    if (!performGravity && !performCaptcha && !performVehicle) {
+      // Save some work by finishing before sending even more packets
+      finish();
+      return;
+    }
    // Set the state to POSITION to avoid false positives
    // and go on with the flow of the verification.
-    state = State.POSITION;
+    user.setState(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
@@ -197,29 +204,27 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
    }
    // Teleport player into the fake lobby by sending an empty chunk
    user.delayedWrite(EMPTY_CHUNK_DATA);
+    // Checking gravity is disabled, just finish verification
+    if (!performGravity) {
+      // Switch to captcha state if needed
+      vehicleCheckOrNext();
+      return;
+    }
    // Send an UpdateSectionBlocks packet with a platform of blocks
    // to check if the player collides with the solid platform.
    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();
-    }
+    // 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().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 {
@@ -227,11 +232,11 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
      // 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()) {
+      if (read.length() > Sonar.get().getConfig().getVerification().getBrand().getMaxLength()) {
        return false;
      }
      // Regex pattern for validating client brands
-      final Pattern pattern = Sonar.get().getConfig().getVerification().getValidBrandRegex();
+      final Pattern pattern = Sonar.get().getConfig().getVerification().getBrand().getValidRegex();
      return !read.equals("Vanilla") // The normal brand is always lowercase
        && pattern.matcher(read).matches(); // Disallow non-ascii characters (by default)
    } catch (DecoderException exception) {
@@ -242,81 +247,97 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
    }
  }

-  @Override
-  public void handle(final @NotNull FallbackPacket packet) {
-    // 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().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");
+  private void handlePacketsCAPTCHA(final @NotNull FallbackPacket packet) {
+    // Check if the player took too long to enter the captcha
+    final int maxDuration = Sonar.get().getConfig().getVerification().getMap().getMaxDuration();
+    checkFrame(!login.elapsed(maxDuration), "took too long to enter captcha");

-      // 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();
+    // Handle incoming chat messages
+    if (packet instanceof UniversalChatPacket) {
+      checkFrame(captcha != null, "Captcha not sent yet");
+      final UniversalChatPacket chat = (UniversalChatPacket) packet;
+      if (!chat.getMessage().equals(captcha.getAnswer())) {
+        // Captcha is incorrect
+        checkFrame(captchaTriesLeft-- > 0, "failed captcha too often");
+        user.write(incorrectCaptcha);
        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();
-      }
+      // Captcha is correct
+      finish();
      return;
    }

-    // Check if the player is not sending a ton of packets to the server
-    final int maxPackets = Sonar.get().getConfig().getVerification().getMaxLoginPackets() + maxMovementTick;
+    // Every second
+    if (actionBar.elapsed(user.getProtocolVersion().compareTo(MINECRAFT_1_8) < 0 ? 10_000L : 1_000L)) {
+      final String actionBarMessage = Sonar.get().getConfig().getVerification().getMap().getEnterCodeActionBar();
+      // Only send action bar if the message is actually supposed to be sent
+      if (!actionBarMessage.isEmpty()) {
+        final String timeLeft = String.format("%.0f", (maxDuration - login.delay()) / 1000D);
+        user.write(new UniversalChatPacket(MiniMessage.miniMessage().deserialize(
+          actionBarMessage.replace("%time-left%", timeLeft)), UniversalChatPacket.GAME_INFO_TYPE));
+        // Make sure to reset the timer
+        actionBar.reset();
+      }
+    }
+
+    // Every 10 seconds
+    if (keepAlive.elapsed(10_000L)) {
+      // Send a KeepAlive packet to prevent timeout
+      user.write(CAPTCHA_KEEP_ALIVE);
+      // Make sure to reset the timer
+      keepAlive.reset();
+    }
+  }
+
+  @Override
+  public void handle(final @NotNull FallbackPacket packet) {
+    // The player has already been verified or failed the verification -> drop packet
+    if (!user.getState().canReceivePackets()) return;
+
+    // Calculate maximum amount of packets sent by the client to the server
+    final int maxPackets = Sonar.get().getConfig().getVerification().getMaxLoginPackets()
+      + maxMovementTick // Account for positions/fall check
+      + Sonar.get().getConfig().getVerification().getMap().getMaxDuration()
+      + Sonar.get().getConfig().getVerification().getMap().getMaxTries();
    checkFrame(++totalReceivedPackets < maxPackets, "too many packets");

-    // Check if the time limit has exceeded
-    if (login.elapsed(timeout)) {
-      user.getChannel().close();
+    // We are expecting a code in chat, drop all other packets
+    if (user.getState() == CAPTCHA) {
+      handlePacketsCAPTCHA(packet);
      return;
    }

-    if (packet instanceof LoginAcknowledged) {
+    if (packet instanceof PlayerInputPacket) {
+      // Check if we are currently expecting a PlayerInputPacket packet
+      assertState(VEHICLE);
+
+      final PlayerInputPacket inputPacket = (PlayerInputPacket) packet;
+
+      // Make sure the values sent by the client are legitimate
+      checkFrame(inputPacket.getForward() <= 0.98f, "invalid vehicle speed (f)");
+      checkFrame(inputPacket.getSideways() <= 0.98f, "invalid vehicle speed (s)");
+
+      // Don't verify if the player tries unmounting or jumping
+      // We can't fail since the player is able to jump or sneak
+      if (inputPacket.isJump() || inputPacket.isUnmount()) return;
+
+      // Continue checking or verify the player
+      captchaOrNext();
+      return;
+    }
+
+    if (packet instanceof LoginAcknowledgedPacket) {
      // Check if we are currently expecting a LoginAcknowledged packet
-      assertState(State.LOGIN_ACK);
+      assertState(LOGIN_ACK);

      // Start the configuration process for 1.20.2 clients
      configure();
+      return;
    }

-    if (packet instanceof FinishConfiguration) {
+    if (packet instanceof FinishConfigurationPacket) {
      // Check if we are currently expecting a FinishConfiguration packet
-      assertState(State.CONFIGURE);
+      assertState(CONFIGURE);

      // Check if the client has already sent valid ClientSettings and PluginMessage packets
      checkFrame(resolvedClientBrand, "did not resolve client brand");
@@ -325,40 +346,44 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
      // Start initializing the actual join process
      updateEncoderDecoderState(FallbackPacketRegistry.GAME);
      initialJoinProcess();
+      return;
    }

-    if (packet instanceof KeepAlive) {
-      final KeepAlive keepAlive = (KeepAlive) packet;
+    if (packet instanceof KeepAlivePacket) {
+      final KeepAlivePacket keepAlive = (KeepAlivePacket) packet;

      // 1.7-1.8.9 are sending a KeepAlive packet with the ID 0 every 20 ticks
      if (keepAlive.getId() == 0 && user.getProtocolVersion().compareTo(MINECRAFT_1_8) <= 0) return;

      // Check if we are currently expecting a KeepAlive packet
-      assertState(State.KEEP_ALIVE);
+      assertState(KEEP_ALIVE);

      checkFrame(keepAlive.getId() == expectedKeepAliveId, "invalid KeepAlive ID");

      // The correct KeepAlive packet has been received
      sendJoinGamePacket();
+      return;
    }

-    if (packet instanceof ClientSettings) {
-      final ClientSettings clientSettings = (ClientSettings) packet;
+    if (packet instanceof ClientSettingsPacket) {
+      final ClientSettingsPacket clientSettings = (ClientSettingsPacket) packet;

      // Validate the locale using a regex to filter unwanted characters.
      checkFrame(validateClientLocale(user, clientSettings.getLocale()), "invalid locale");

      // Clients sometimes mess up the ClientSettings or PluginMessage packet.
-      if (state == State.CLIENT_SETTINGS) {
-        state = State.PLUGIN_MESSAGE;
+      // Probably caused by some weird race condition in Minecraft 1.13+
+      if (user.getState() == CLIENT_SETTINGS) {
+        user.setState(PLUGIN_MESSAGE);
      }

      // Make sure we mark the ClientSettings as valid
      resolvedClientSettings = true;
+      return;
    }

-    if (packet instanceof PluginMessage) {
-      final PluginMessage pluginMessage = (PluginMessage) packet;
+    if (packet instanceof PluginMessagePacket) {
+      final PluginMessagePacket pluginMessage = (PluginMessagePacket) packet;

      // Only the brand channel is important, drop the rest
      if (pluginMessage.getChannel().equals("MC|Brand")
@@ -374,10 +399,12 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
        checkFrame(pluginMessage.getChannel().equals("MC|Brand") || v1_13, "invalid channel");

        // Validate the client branding using a regex to filter unwanted characters.
-        checkFrame(validateClientBrand(user, pluginMessage.content()), "invalid client brand");
+        if (Sonar.get().getConfig().getVerification().getBrand().isEnabled()) {
+          checkFrame(validateClientBrand(user, pluginMessage.getSlicedBuffer()), "invalid client brand");
+        }

        // Clients sometimes mess up the ClientSettings or PluginMessage packet.
-        if (state == State.PLUGIN_MESSAGE) {
+        if (user.getState() == PLUGIN_MESSAGE) {
          // Send the transaction packet
          sendTransaction();
        }
@@ -385,13 +412,14 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
        // Make sure we mark the PluginMessage as valid
        resolvedClientBrand = true;
      }
+      return;
    }

-    if (packet instanceof Transaction) {
+    if (packet instanceof TransactionPacket) {
      // Check if we are currently expecting a Transaction packet
-      assertState(State.TRANSACTION);
+      assertState(TRANSACTION);

-      final Transaction transaction = (Transaction) packet;
+      final TransactionPacket transaction = (TransactionPacket) packet;

      // The transaction should always be accepted
      checkFrame(transaction.isAccepted(), "transaction not accepted?!");
@@ -412,14 +440,15 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
        // the channel earlier when we teleported the player.
        user.getChannel().flush();
      }
+      return;
    }

-    if (packet instanceof TeleportConfirm) {
+    if (packet instanceof TeleportConfirmPacket) {
      // Check if we are currently expecting a TeleportConfirm packet
-      assertState(State.TELEPORT);
+      assertState(TELEPORT);

      // Check if the teleport ID is correct
-      final TeleportConfirm teleportConfirm = (TeleportConfirm) packet;
+      final TeleportConfirmPacket teleportConfirm = (TeleportConfirmPacket) packet;
      checkFrame(teleportConfirm.getTeleportId() == expectedTeleportId, "invalid teleport ID");

      // Reset all values to ensure safety on teleport
@@ -429,140 +458,194 @@ public final class FallbackVerificationHandler implements FallbackPacketListener

      // Now we can send the chunk data
      sendChunkData();
+      return;
    }

-    if (state != State.LOGIN_ACK) {
-      if (packet instanceof Position) {
-        final Position position = (Position) packet;
+    if (user.getState() != LOGIN_ACK) {
+      if (packet instanceof PlayerPositionPacket) {
+        final PlayerPositionPacket position = (PlayerPositionPacket) packet;
        handlePositionUpdate(position.getX(), position.getY(), position.getZ(), position.isOnGround());
+        return;
      }

-      if (packet instanceof PositionLook) {
-        final PositionLook position = (PositionLook) packet;
+      if (packet instanceof PlayerPositionLookPacket) {
+        final PlayerPositionLookPacket position = (PlayerPositionLookPacket) packet;
        handlePositionUpdate(position.getX(), position.getY(), position.getZ(), position.isOnGround());
+        return;
      }

-      if (packet instanceof Player) {
-        final Player player = (Player) packet;
+      if (packet instanceof PlayerTickPacket) {
+        final PlayerTickPacket player = (PlayerTickPacket) packet;
        handlePositionUpdate(posX, posY, posZ, player.isOnGround());
      }
    }
  }

  private void handlePositionUpdate(final double x, final double y, final double z, final boolean ground) {
-    // 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;
-    }
-
-    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)");
-
-    // 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;
+    try {
+      // 1.8 does not have a TeleportConfirm packet, so we need to handle the spawning differently
+      if (user.getProtocolVersion().compareTo(MINECRAFT_1_8) <= 0
+        && expectedTeleportId != -1 // Check if the teleport ID is currently unset
+        // Then, check if the position is equal to the spawn position
+        && x == SPAWN_X_POSITION && y == spawnYPosition && z == SPAWN_Z_POSITION) {
+        // Reset all values to ensure safety on teleport
+        tick = 1;
+        posY = -1;
+        expectedTeleportId = -1;
+        // Check for ground state in the first packet
+        checkFrame(!ground, "invalid ground state");
      }

-      lastY = dynamicSpawnYPosition;
-      return;
-    }
+      posX = x;
+      lastY = posY;
+      posY = y;
+      posZ = z;

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

-    // 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 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;
+        }

-    // 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();
+        lastY = spawnYPosition;
        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");
+      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) return;

-    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);
+      // Calculate the difference between the player's Y coordinate and the expected Y coordinate
+      double collisionOffsetY = (DEFAULT_Y_COLLIDE_POSITION + blockType.getBlockHeight()) - y;
+      if (user.getProtocolVersion().compareTo(MINECRAFT_1_8) < 0) {
+        collisionOffsetY += 1.62f; // 1.7 is weird and sends the head position instead of the AABB minY
      }

-      // Check if the 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));
+      // Check if the player is colliding by performing a basic Y offset check.
+      // The offset cannot be greater than 0 since the blocks will not let the player fall through them.
+      checkFrame(collisionOffsetY <= 0, "fell through blocks: " + collisionOffsetY);
+
+      if (tick > maxMovementTick) {
+        // Log/debug position if enabled in the configuration
+        if (Sonar.get().getConfig().getVerification().isDebugXYZPositions()) {
+          FALLBACK.getLogger().info("{}: {}/{}/{} - deltaY: {} - ground: {} - collision: {}",
+            username, x, y, z, deltaY, ground, collisionOffsetY);
+        }
+
+        // If the collision check is disabled, finish verification
+        if (!performCollisions) {
+          vehicleCheckOrNext();
+          return;
+        }
+
+        // Perform the collision check
+        if (ground) {
+          // Make sure the player is actually colliding with the blocks and not only spoofing ground
+          checkFrame(collisionOffsetY > -0.03, "illegal collision: " + collisionOffsetY);
+          // The player is colliding to blocks, finish verification
+          vehicleCheckOrNext();
+          return;
+        } else {
+          // Make sure the player is colliding with blocks but is sending an invalid ground state
+          checkFrame(collisionOffsetY != 0, "no ground: " + collisionOffsetY);
+        }
+      } else {
+        // Check if the player is spoofing the ground state
+        checkFrame(!ground, "spoofed ground state");
+      }
+
+      // Make sure we don't run out of predicted Y motions
+      checkFrame(tick < preparedCachedYMotions.length, "too many movements");
+
+      if (!ground) {
+        final double predictedY = preparedCachedYMotions[tick];
+        final double offsetY = Math.abs(deltaY - predictedY);
+
+        // Log/debug position if enabled in the configuration
+        if (Sonar.get().getConfig().getVerification().isDebugXYZPositions()) {
+          FALLBACK.getLogger().info("{}: {}/{}/{} - deltaY: {} - prediction: {} - offset: {}",
+            username, x, y, z, deltaY, predictedY, offsetY);
+        }
+
+        // Check if the y motion is roughly equal to the predicted value
+        checkFrame(offsetY < 0.005, String.format("invalid gravity: %d, %.7f, %.10f, %.10f != %.10f",
+          tick, y, offsetY, deltaY, predictedY));
+      }
+      tick++;
+    } catch (CorruptedFrameException exception) {
+      // Do not throw the exception if the user configured to display the CAPTCHA instead
+      if (Sonar.get().getConfig().getVerification().getGravity().isCaptchaOnFail()) {
+        handleCAPTCHA();
+        return;
+      }
+      // Interrupt the netty eventLoop to immediately stop further processing
+      throw new DecoderException(exception);
    }
-    tick++;
  }

-  private void captchaOrFinish() {
-    if (Sonar.get().getConfig().getVerification().getMap().isEnabled()) {
-      // 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);
-      }
+  // TODO: Maybe recode the flow with a better state system?
+  private void vehicleCheckOrNext() {
+    if (performVehicle) {
+      // Initialize the vehicle check
+      handleVehicleCheck();
+      return;
+    }
+    captchaOrNext();
+  }
+
+  private void captchaOrNext() {
+    if (performCaptcha) {
      // Initialize the map captcha
-      handleMapCaptcha();
-    } else {
-      // Finish the verification
-      finish();
+      handleCAPTCHA();
+      return;
    }
+    // Finish the verification
+    finish();
  }

-  private void handleMapCaptcha() {
+  private void handleVehicleCheck() {
+    // Set the state to VEHICLE, so we don't handle any unnecessary packets
+    user.setState(VEHICLE);
+    // Send the necessary packets to mount the player on the vehicle
+    final int vehicleType = EntityType.BOAT.getId(user.getProtocolVersion());
+    user.delayedWrite(new SpawnEntityPacket(VEHICLE_ENTITY_ID, vehicleType, posX, posY, posZ));
+    user.delayedWrite(setPassengers);
+    user.getChannel().flush();
+  }
+
+  private void handleCAPTCHA() {
+    // Set the state to CAPTCHA, so we don't handle any unnecessary packets
+    user.setState(CAPTCHA);
+    if (!MAP_INFO_PREPARER.isCaptchaAvailable()) {
+      // This should not happen, but we have to return if there is no captcha prepared
+      user.disconnect(Sonar.get().getConfig().getVerification().getCurrentlyPreparing());
+      return;
+    }
+    if (!performGravity
+      && 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);
+    }
+    if (performVehicle) {
+      // Make sure the player exits the vehicle before sending the CAPTCHA
+      user.delayedWrite(removeEntities);
+    }
    // Reset max tries
    captchaTriesLeft = Sonar.get().getConfig().getVerification().getMap().getMaxTries();

    // Set slot to map
-    user.delayedWrite(new SetSlot(0, 36, 1, 0,
-      ItemMapType.FILLED_MAP.getId(user.getProtocolVersion()), SetSlot.MAP_NBT));
+    user.delayedWrite(new SetSlotPacket(0, 36, 1, 0,
+      ItemType.FILLED_MAP.getId(user.getProtocolVersion()), SetSlotPacket.MAP_NBT));
    // Send random captcha to the player
-    captcha = MapInfoPreparer.getRandomCaptcha();
-    Objects.requireNonNull(captcha).write(user);
+    captcha = MAP_INFO_PREPARER.getRandomCaptcha();
+    Objects.requireNonNull(captcha).delayedWrite(user);
    // Teleport the player to the position above the platform
    user.delayedWrite(CAPTCHA_POSITION);
    // Make sure the player cannot move
@@ -574,9 +657,11 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
  }

  private void finish() {
-    state = State.SUCCESS;
+    // Make sure we drop all further packets
+    user.setState(SUCCESS);

-    user.getFallback().getConnected().remove(username);
+    // Increment amount of total successful verifications
+    GlobalSonarStatistics.totalSuccessfulVerifications++;

    // Add verified player to the database
    final VerifiedPlayer verifiedPlayer = new VerifiedPlayer(user.getInetAddress().toString(), playerUuid,
@@ -589,7 +674,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
    // Disconnect player with the verification success message
    user.disconnect(Sonar.get().getConfig().getVerification().getVerificationSuccess());

-    user.getFallback().getLogger().info(Sonar.get().getConfig().getVerification().getSuccessLog()
+    FALLBACK.getLogger().info(Sonar.get().getConfig().getVerification().getSuccessLog()
      .replace("%name%", username)
      .replace("%time%", login.toString()));
  }
@@ -599,7 +684,8 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
   *
   * @param expectedState Expected state
   */
-  private void assertState(final @NotNull State expectedState) {
+  private void assertState(final @NotNull FallbackUserState expectedState) {
+    final FallbackUserState state = user.getState();
    checkFrame(state == expectedState, "expected " + expectedState + ", got " + state);
  }

@@ -609,9 +695,14 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
   * @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) {
+  private void checkFrame(final boolean condition, final @NotNull String message) {
    if (!condition) {
-      user.fail(message);
+      // Only fail the player if we are either not in the POSITION state,
+      // or if the user configured Sonar to display a CAPTCHA instead of failing.
+      if (user.getState() != POSITION
+        || !Sonar.get().getConfig().getVerification().getGravity().isCaptchaOnFail()) {
+        user.fail(message);
+      }
      throw new CorruptedFrameException(message);
    }
  }
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-package xyz.jonesdev.sonar.common.fallback.protocol.netty;
+package xyz.jonesdev.sonar.common.fallback.netty;

 import org.jetbrains.annotations.NotNull;

@@ -24,6 +24,7 @@ import java.util.UUID;
 // Taken from
 // https://github.com/PaperMC/Velocity/blob/dev/3.0.0/api/src/main/java/com/velocitypowered/api/util/FastUuidSansHyphens.java
 public final class FastUUID {
+  public static final UUID EMPTY_UUID = new UUID(0L, 0L);
  private static final int MOJANG_BROKEN_UUID_LENGTH = 32;

  private static final char[] HEX_DIGITS =
@@ -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
@@ -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,11 +31,11 @@ import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry
 import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.readVarInt;

 public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
-  private final FallbackUser<?, ?> user;
+  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.listener = listener;
@@ -98,10 +98,6 @@ public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
        // 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?!");
    }
  }

@@ -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
@@ -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
@@ -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,10 +22,10 @@ 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.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.config.FinishConfigurationPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.RegistryDataPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginAcknowledgedPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginSuccessPacket;
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;

 import java.util.*;
@@ -38,37 +38,40 @@ import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.*;
 public enum FallbackPacketRegistry {
  LOGIN {
    {
-      serverbound.register(LoginAcknowledged.class, LoginAcknowledged::new,
+      serverbound.register(LoginAcknowledgedPacket.class, LoginAcknowledgedPacket::new,
        map(0x03, MINECRAFT_1_20_2, false));

-      clientbound.register(LoginSuccess.class, LoginSuccess::new,
+      clientbound.register(LoginSuccessPacket.class, LoginSuccessPacket::new,
        map(0x02, MINECRAFT_1_7_2, false));
+
+      clientbound.register(DisconnectPacket.class, DisconnectPacket::new,
+        map(0x00, MINECRAFT_1_7_2, true));
    }
  },
  CONFIG {
    {
-      clientbound.register(Disconnect.class, Disconnect::new,
+      clientbound.register(DisconnectPacket.class, DisconnectPacket::new,
        map(0x01, MINECRAFT_1_20_2, true));
-      clientbound.register(FinishConfiguration.class, FinishConfiguration::new,
+      clientbound.register(FinishConfigurationPacket.class, FinishConfigurationPacket::new,
        map(0x02, MINECRAFT_1_20_2, false));
-      clientbound.register(KeepAlive.class, KeepAlive::new,
+      clientbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
        map(0x03, MINECRAFT_1_20_2, false));
-      clientbound.register(RegistryData.class, RegistryData::new,
+      clientbound.register(RegistryDataPacket.class, RegistryDataPacket::new,
        map(0x05, MINECRAFT_1_20_2, true));

-      serverbound.register(ClientSettings.class, ClientSettings::new,
+      serverbound.register(ClientSettingsPacket.class, ClientSettingsPacket::new,
        map(0x00, MINECRAFT_1_20_2, false));
-      serverbound.register(PluginMessage.class, PluginMessage::new,
+      serverbound.register(PluginMessagePacket.class, PluginMessagePacket::new,
        map(0x01, MINECRAFT_1_20_2, false));
-      serverbound.register(FinishConfiguration.class, FinishConfiguration::new,
+      serverbound.register(FinishConfigurationPacket.class, FinishConfigurationPacket::new,
        map(0x02, MINECRAFT_1_20_2, false));
-      serverbound.register(KeepAlive.class, KeepAlive::new,
+      serverbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
        map(0x03, MINECRAFT_1_20_2, false));
    }
  },
  GAME {
    {
-      clientbound.register(JoinGame.class, JoinGame::new,
+      clientbound.register(JoinGamePacket.class, JoinGamePacket::new,
        map(0x01, MINECRAFT_1_7_2, true),
        map(0x23, MINECRAFT_1_9, true),
        map(0x25, MINECRAFT_1_13, true),
@@ -82,7 +85,7 @@ public enum FallbackPacketRegistry {
        map(0x24, MINECRAFT_1_19_3, true),
        map(0x28, MINECRAFT_1_19_4, true),
        map(0x29, MINECRAFT_1_20_2, true));
-      clientbound.register(KeepAlive.class, KeepAlive::new,
+      clientbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
        map(0x00, MINECRAFT_1_7_2, false),
        map(0x1F, MINECRAFT_1_9, false),
        map(0x21, MINECRAFT_1_13, false),
@@ -96,7 +99,7 @@ public enum FallbackPacketRegistry {
        map(0x1F, MINECRAFT_1_19_3, false),
        map(0x23, MINECRAFT_1_19_4, false),
        map(0x24, MINECRAFT_1_20_2, false));
-      clientbound.register(Disconnect.class, Disconnect::new,
+      clientbound.register(DisconnectPacket.class, DisconnectPacket::new,
        map(0x40, MINECRAFT_1_7_2, true),
        map(0x1A, MINECRAFT_1_9, true),
        map(0x1B, MINECRAFT_1_13, true),
@@ -110,7 +113,7 @@ public enum FallbackPacketRegistry {
        map(0x17, MINECRAFT_1_19_3, true),
        map(0x1A, MINECRAFT_1_19_4, true),
        map(0x1B, MINECRAFT_1_20_2, true));
-      clientbound.register(PositionLook.class, PositionLook::new,
+      clientbound.register(PlayerPositionLookPacket.class, PlayerPositionLookPacket::new,
        map(0x08, MINECRAFT_1_7_2, true),
        map(0x2E, MINECRAFT_1_9, true),
        map(0x2F, MINECRAFT_1_12_1, true),
@@ -125,7 +128,7 @@ public enum FallbackPacketRegistry {
        map(0x38, MINECRAFT_1_19_3, true),
        map(0x3C, MINECRAFT_1_19_4, true),
        map(0x3E, MINECRAFT_1_20_2, true));
-      clientbound.register(Abilities.class, Abilities::new,
+      clientbound.register(ClientAbilitiesPacket.class, ClientAbilitiesPacket::new,
        map(0x39, MINECRAFT_1_7_2, true),
        map(0x2B, MINECRAFT_1_9, true),
        map(0x2C, MINECRAFT_1_12_1, true),
@@ -140,7 +143,7 @@ public enum FallbackPacketRegistry {
        map(0x30, MINECRAFT_1_19_3, true),
        map(0x34, MINECRAFT_1_19_4, true),
        map(0x36, MINECRAFT_1_20_2, true));
-      clientbound.register(EmptyChunkData.class, EmptyChunkData::new,
+      clientbound.register(ChunkDataPacket.class, ChunkDataPacket::new,
        map(0x21, MINECRAFT_1_7_2, true),
        map(0x20, MINECRAFT_1_9, true),
        map(0x22, MINECRAFT_1_13, true),
@@ -154,7 +157,42 @@ public enum FallbackPacketRegistry {
        map(0x20, MINECRAFT_1_19_3, true),
        map(0x24, MINECRAFT_1_19_4, true),
        map(0x25, MINECRAFT_1_20_2, true));
-      clientbound.register(UpdateSectionBlocks.class, UpdateSectionBlocks::new,
+      clientbound.register(RemoveEntitiesPacket.class, RemoveEntitiesPacket::new,
+        map(0x13, MINECRAFT_1_7_2, true),
+        map(0x30, MINECRAFT_1_9, true),
+        map(0x31, MINECRAFT_1_12, true),
+        map(0x32, MINECRAFT_1_12_2, true),
+        map(0x35, MINECRAFT_1_13, true),
+        map(0x37, MINECRAFT_1_14, true),
+        map(0x38, MINECRAFT_1_15, true),
+        map(0x37, MINECRAFT_1_16, true),
+        map(0x36, MINECRAFT_1_16_2, true),
+        map(0x3A, MINECRAFT_1_17, true),
+        map(0x38, MINECRAFT_1_19, true),
+        map(0x3B, MINECRAFT_1_19_1, true),
+        map(0x3A, MINECRAFT_1_19_3, true),
+        map(0x3E, MINECRAFT_1_19_4, true),
+        map(0x3E, MINECRAFT_1_19_4, true),
+        map(0x40, MINECRAFT_1_20_2, true));
+      clientbound.register(SetPassengersPacket.class, SetPassengersPacket::new,
+        map(0x1B, MINECRAFT_1_7_2, true),
+        map(0x40, MINECRAFT_1_9, true),
+        map(0x42, MINECRAFT_1_12, true),
+        map(0x43, MINECRAFT_1_12_1, true),
+        map(0x46, MINECRAFT_1_13, true),
+        map(0x4A, MINECRAFT_1_14, true),
+        map(0x4B, MINECRAFT_1_15, true),
+        map(0x54, MINECRAFT_1_17, true),
+        map(0x57, MINECRAFT_1_19_1, true),
+        map(0x55, MINECRAFT_1_19_3, true),
+        map(0x59, MINECRAFT_1_19_4, true),
+        map(0x5B, MINECRAFT_1_20_2, true),
+        map(0x5D, MINECRAFT_1_20_3, true));
+      clientbound.register(SpawnEntityPacket.class, SpawnEntityPacket::new,
+        map(0x0E, MINECRAFT_1_7_2, true),
+        map(0x00, MINECRAFT_1_9, true),
+        map(0x01, MINECRAFT_1_19_4, true));
+      clientbound.register(UpdateSectionBlocksPacket.class, UpdateSectionBlocksPacket::new,
        map(0x22, MINECRAFT_1_7_2, true),
        map(0x10, MINECRAFT_1_9, true),
        map(0x0F, MINECRAFT_1_13, true),
@@ -168,7 +206,7 @@ public enum FallbackPacketRegistry {
        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,
+      clientbound.register(TransactionPacket.class, TransactionPacket::new,
        map(0x32, MINECRAFT_1_7_2, true),
        map(0x11, MINECRAFT_1_9, true),
        map(0x12, MINECRAFT_1_13, true),
@@ -181,7 +219,7 @@ public enum FallbackPacketRegistry {
        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,
+      clientbound.register(DefaultSpawnPositionPacket.class, DefaultSpawnPositionPacket::new,
        map(0x05, MINECRAFT_1_7_2, true),
        map(0x43, MINECRAFT_1_9, true),
        map(0x45, MINECRAFT_1_12, true),
@@ -197,7 +235,7 @@ public enum FallbackPacketRegistry {
        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,
+      clientbound.register(MapDataPacket.class, MapDataPacket::new,
        map(0x34, MINECRAFT_1_7_2, true),
        map(0x24, MINECRAFT_1_9, true),
        map(0x26, MINECRAFT_1_13, true),
@@ -210,7 +248,7 @@ public enum FallbackPacketRegistry {
        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,
+      clientbound.register(SetSlotPacket.class, SetSlotPacket::new,
        map(0x2F, MINECRAFT_1_7_2, true),
        map(0x16, MINECRAFT_1_9, true),
        map(0x17, MINECRAFT_1_13, true),
@@ -223,7 +261,7 @@ public enum FallbackPacketRegistry {
        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,
+      clientbound.register(UniversalChatPacket.class, UniversalChatPacket::new,
        map(0x02, MINECRAFT_1_7_2, false),
        map(0x0F, MINECRAFT_1_9, false),
        map(0x0E, MINECRAFT_1_13, false),
@@ -235,11 +273,25 @@ public enum FallbackPacketRegistry {
        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_2, false));
-      clientbound.register(GameEvent.class, GameEvent::new,
+        map(0x69, MINECRAFT_1_20_3, false));
+      clientbound.register(GameEventPacket.class, GameEventPacket::new,
        map(0x20, MINECRAFT_1_20_3, true));

-      serverbound.register(Chat.class, Chat::new,
+      serverbound.register(PlayerInputPacket.class, PlayerInputPacket::new,
+        map(0x0C, MINECRAFT_1_7_2, false),
+        map(0x15, MINECRAFT_1_9, false),
+        map(0x16, MINECRAFT_1_12, false),
+        map(0x1A, MINECRAFT_1_13, false),
+        map(0x1C, MINECRAFT_1_14, false),
+        map(0x1D, MINECRAFT_1_16, false),
+        map(0x1C, MINECRAFT_1_17, false),
+        map(0x1E, MINECRAFT_1_19, false),
+        map(0x1F, MINECRAFT_1_19_1, false),
+        map(0x1E, MINECRAFT_1_19_3, false),
+        map(0x1F, MINECRAFT_1_19_4, false),
+        map(0x22, MINECRAFT_1_20_2, false),
+        map(0x23, MINECRAFT_1_20_3, false));
+      serverbound.register(UniversalChatPacket.class, UniversalChatPacket::new,
        map(0x01, MINECRAFT_1_7_2, false),
        map(0x02, MINECRAFT_1_9, false),
        map(0x03, MINECRAFT_1_12, false),
@@ -248,7 +300,7 @@ public enum FallbackPacketRegistry {
        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,
+      serverbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
        map(0x00, MINECRAFT_1_7_2, false),
        map(0x0B, MINECRAFT_1_9, false),
        map(0x0C, MINECRAFT_1_12, false),
@@ -263,7 +315,7 @@ public enum FallbackPacketRegistry {
        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,
+      serverbound.register(ClientSettingsPacket.class, ClientSettingsPacket::new,
        map(0x15, MINECRAFT_1_7_2, false),
        map(0x04, MINECRAFT_1_9, false),
        map(0x05, MINECRAFT_1_12, false),
@@ -274,7 +326,7 @@ public enum FallbackPacketRegistry {
        map(0x07, MINECRAFT_1_19_3, false),
        map(0x08, MINECRAFT_1_19_4, false),
        map(0x09, MINECRAFT_1_20_2, false));
-      serverbound.register(PluginMessage.class, PluginMessage::new,
+      serverbound.register(PluginMessagePacket.class, PluginMessagePacket::new,
        map(0x17, MINECRAFT_1_7_2, false),
        map(0x09, MINECRAFT_1_9, false),
        map(0x0A, MINECRAFT_1_12, false),
@@ -287,7 +339,7 @@ public enum FallbackPacketRegistry {
        map(0x0C, MINECRAFT_1_19_3, false),
        map(0x0D, MINECRAFT_1_19_4, false),
        map(0x0F, MINECRAFT_1_20_2, false));
-      serverbound.register(PositionLook.class, PositionLook::new,
+      serverbound.register(PlayerPositionLookPacket.class, PlayerPositionLookPacket::new,
        map(0x06, MINECRAFT_1_7_2, false),
        map(0x0D, MINECRAFT_1_9, false),
        map(0x0F, MINECRAFT_1_12, false),
@@ -302,9 +354,9 @@ public enum FallbackPacketRegistry {
        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,
+      serverbound.register(TeleportConfirmPacket.class, TeleportConfirmPacket::new,
        map(0x00, MINECRAFT_1_9, false));
-      serverbound.register(Position.class, Position::new,
+      serverbound.register(PlayerPositionPacket.class, PlayerPositionPacket::new,
        map(0x04, MINECRAFT_1_7_2, false),
        map(0x0C, MINECRAFT_1_9, false),
        map(0x0E, MINECRAFT_1_12, false),
@@ -319,7 +371,7 @@ public enum FallbackPacketRegistry {
        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,
+      serverbound.register(PlayerTickPacket.class, PlayerTickPacket::new,
        map(0x03, MINECRAFT_1_7_2, false),
        map(0x0F, MINECRAFT_1_9, false),
        map(0x0D, MINECRAFT_1_12, false),
@@ -334,7 +386,7 @@ public enum FallbackPacketRegistry {
        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,
+      serverbound.register(TransactionPacket.class, TransactionPacket::new,
        map(0x0F, MINECRAFT_1_7_2, false),
        map(0x05, MINECRAFT_1_9, false),
        map(0x06, MINECRAFT_1_12, false),
@@ -370,7 +422,7 @@ public enum FallbackPacketRegistry {
    PacketRegistry() {
      final Map<ProtocolVersion, ProtocolRegistry> mutableVersions = new EnumMap<>(ProtocolVersion.class);
      for (final ProtocolVersion version : ProtocolVersion.values()) {
-        if (!version.isLegacy() && !version.isUnknown()) {
+        if (!version.isUnknown()) {
          mutableVersions.put(version, new ProtocolRegistry(version));
        }
      }
@@ -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,58 @@ package xyz.jonesdev.sonar.common.fallback.protocol;

 import lombok.experimental.UtilityClass;
 import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.timer.SystemTimer;
+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.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.map.CaptchaPreparer;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.FinishConfigurationPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.RegistryDataPacket;
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;

+import java.util.concurrent.ThreadLocalRandom;
+
@UtilityClass
 public class FallbackPreparer {

  // Abilities
-  public final FallbackPacket DEFAULT_ABILITIES = new Abilities(0x00, 0f, 0f);
-  public final FallbackPacket CAPTCHA_ABILITIES = new Abilities(0x02, 0f, 0f);
+  public final FallbackPacket DEFAULT_ABILITIES = new ClientAbilitiesPacket(0x00, 0f, 0f);
+  public final FallbackPacket CAPTCHA_ABILITIES = new ClientAbilitiesPacket(0x02, 0f, 0f);
  // Chunks
-  public final FallbackPacket EMPTY_CHUNK_DATA = new EmptyChunkData(0, 0);
+  public final FallbackPacket EMPTY_CHUNK_DATA = new ChunkDataPacket(0, 0);
  // Finish Configuration
-  public final FallbackPacket FINISH_CONFIGURATION = new FinishConfiguration();
+  public final FallbackPacket FINISH_CONFIGURATION = new FinishConfigurationPacket();
  // Synchronize Registry
-  public final FallbackPacket REGISTRY_SYNC = new RegistryData();
+  public final FallbackPacket REGISTRY_SYNC = new RegistryDataPacket();
  // Keep Alive
-  public final FallbackPacket CAPTCHA_KEEP_ALIVE = new KeepAlive(0L);
+  public final FallbackPacket CAPTCHA_KEEP_ALIVE = new KeepAlivePacket(0L);
  // Game Event (1.20.3+)
-  public final FallbackPacket START_WRITING_CHUNKS = new GameEvent(13, 0);
+  public final FallbackPacket START_WRITING_CHUNKS = new GameEventPacket(13, 0);
  // Chat
  public FallbackPacket enterCodeMessage;
-  public FallbackPacket youAreBeingChecked;
  public FallbackPacket incorrectCaptcha;
  // JoinGame
+  public final int PLAYER_ENTITY_ID = ThreadLocalRandom.current().nextInt(10);
  public FallbackPacket joinGame;
  // Update Section Blocks
  public FallbackPacket updateSectionBlocks;
  // Default Spawn Position
  public FallbackPacket dynamicSpawnPosition;

+  // Disconnect messages
+  public FallbackPacket blacklisted;
+  public FallbackPacket alreadyQueued;
+  public FallbackPacket alreadyVerifying;
+  public FallbackPacket reconnectedTooFast;
+  public FallbackPacket protocolBlacklisted;
+  public FallbackPacket invalidUsername;
+  public FallbackPacket tooManyOnlinePerIP;
+
+  // Vehicle
+  public FallbackPacket removeEntities;
+  public FallbackPacket setPassengers;
+  public static final int VEHICLE_ENTITY_ID = PLAYER_ENTITY_ID + 1;
+
  // Collisions
  public final int BLOCKS_PER_ROW = 8; // 8 * 8 = 64 (protocol maximum)
  public final int SPAWN_X_POSITION = 16 / 2; // middle of the chunk
@@ -62,29 +78,28 @@ public class FallbackPreparer {
  public final int DEFAULT_Y_COLLIDE_POSITION = 255; // 255 is the maximum Y position allowed

  // Captcha position
-  public final FallbackPacket CAPTCHA_POSITION = new PositionLook(
+  public final FallbackPacket CAPTCHA_POSITION = new PlayerPositionLookPacket(
    SPAWN_X_POSITION, 1337, SPAWN_Z_POSITION, 0f, 90f, 0, false);
-  public final FallbackPacket CAPTCHA_SPAWN_POSITION = new DefaultSpawnPosition(
+  public final FallbackPacket CAPTCHA_SPAWN_POSITION = new DefaultSpawnPositionPacket(
    SPAWN_X_POSITION, 1337, SPAWN_Z_POSITION);

  // Blocks
  private final ChangedBlock[] CHANGED_BLOCKS = new ChangedBlock[BLOCKS_PER_ROW * BLOCKS_PER_ROW];
+  public BlockType blockType = BlockType.BARRIER;

  public int maxMovementTick, dynamicSpawnYPosition;
  public double[] preparedCachedYMotions;
  public double maxFallDistance;

+  // CAPTCHA
+  public final CaptchaPreparer MAP_INFO_PREPARER = new CaptchaPreparer();
+
  public void prepare() {
-    joinGame = new JoinGame(0,
+    joinGame = new JoinGamePacket(PLAYER_ENTITY_ID,
      Sonar.get().getConfig().getVerification().getGravity().getGamemode().getId(),
-      0,
-      false,
-      0,
-      true,
-      true,
-      false,
-      new String[]{"minecraft:overworld"},
-      "minecraft:overworld");
+      0, false, 0,
+      true, false, false,
+      new String[]{"minecraft:overworld"}, "minecraft:overworld");

    maxFallDistance = 0;
    maxMovementTick = Sonar.get().getConfig().getVerification().getGravity().getMaxMovementTicks();
@@ -98,7 +113,7 @@ public class FallbackPreparer {

    // Set the dynamic block and collide Y position based on the maximum fall distance
    dynamicSpawnYPosition = DEFAULT_Y_COLLIDE_POSITION + (int) Math.ceil(maxFallDistance);
-    dynamicSpawnPosition = new DefaultSpawnPosition(SPAWN_X_POSITION, dynamicSpawnYPosition, SPAWN_Z_POSITION);
+    dynamicSpawnPosition = new DefaultSpawnPositionPacket(SPAWN_X_POSITION, dynamicSpawnYPosition, SPAWN_Z_POSITION);

    // Prepare collision platform positions
    int index = 0;
@@ -109,27 +124,34 @@ public class FallbackPreparer {
          DEFAULT_Y_COLLIDE_POSITION,
          z + (BLOCKS_PER_ROW / 2),
          0, 0);
-        CHANGED_BLOCKS[index++] = new ChangedBlock(position, BlockType.BARRIER);
+        CHANGED_BLOCKS[index++] = new ChangedBlock(position, blockType);
      }
    }

    // Prepare UpdateSectionBlocks packet
-    updateSectionBlocks = new UpdateSectionBlocks(0, 0, CHANGED_BLOCKS);
+    updateSectionBlocks = new UpdateSectionBlocksPacket(0, 0, CHANGED_BLOCKS);

-    // "You are being checked" message
-    if (Sonar.get().getConfig().getVerification().getGravity().isEnabled()) {
-      youAreBeingChecked = new Chat(Sonar.get().getConfig().getVerification().getGravity().getYouAreBeingChecked());
+    // Prepare disconnect packets during login
+    blacklisted = DisconnectPacket.create(Sonar.get().getConfig().getVerification().getBlacklisted(), true);
+    alreadyVerifying = DisconnectPacket.create(Sonar.get().getConfig().getVerification().getAlreadyVerifying(), true);
+    alreadyQueued = DisconnectPacket.create(Sonar.get().getConfig().getVerification().getAlreadyQueued(), true);
+    protocolBlacklisted = DisconnectPacket.create(Sonar.get().getConfig().getVerification().getProtocolBlacklisted(), true);
+    reconnectedTooFast = DisconnectPacket.create(Sonar.get().getConfig().getVerification().getTooFastReconnect(), true);
+    invalidUsername = DisconnectPacket.create(Sonar.get().getConfig().getVerification().getInvalidUsername(), true);
+    tooManyOnlinePerIP = DisconnectPacket.create(Sonar.get().getConfig().getTooManyOnlinePerIp(), true);
+
+    // Precompute captcha answers
+    if (Sonar.get().getConfig().getVerification().getMap().getTiming() != SonarConfiguration.Verification.Timing.NEVER
+      || Sonar.get().getConfig().getVerification().getGravity().isCaptchaOnFail()) {
+      enterCodeMessage = new UniversalChatPacket(Sonar.get().getConfig().getVerification().getMap().getEnterCode(), UniversalChatPacket.SYSTEM_TYPE);
+      incorrectCaptcha = new UniversalChatPacket(
+        Sonar.get().getConfig().getVerification().getMap().getFailedCaptcha(), UniversalChatPacket.SYSTEM_TYPE);
+
+      MAP_INFO_PREPARER.prepare();
    }

-    if (Sonar.get().getConfig().getVerification().getMap().isEnabled()) {
-      enterCodeMessage = new Chat(Sonar.get().getConfig().getVerification().getMap().getEnterCode());
-      incorrectCaptcha = new Chat(Sonar.get().getConfig().getVerification().getMap().getFailedCaptcha());
-
-      final SystemTimer timer = new SystemTimer();
-      Sonar.get().getLogger().info("Precomputing map captcha answers...");
-      // Precompute captcha answers
-      MapInfoPreparer.prepare();
-      Sonar.get().getLogger().info("Successfully precomputed captcha answers in {}s!", timer);
-    }
+    // Prepare packets for the vehicle check
+    removeEntities = new RemoveEntitiesPacket(VEHICLE_ENTITY_ID);
+    setPassengers = new SetPassengersPacket(VEHICLE_ENTITY_ID, PLAYER_ENTITY_ID);
  }
 }
@@ -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
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Sonar Contributors
+ * Copyright (C) 2023-2024 Sonar Contributors
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -17,6 +17,7 @@

 package xyz.jonesdev.sonar.common.fallback.protocol.block;

+import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
@@ -26,7 +27,7 @@ import java.util.function.Function;
@SuppressWarnings("unused")
@RequiredArgsConstructor
 public enum BlockType {
-  STONE(protocolVersion -> 1),
+  STONE(protocolVersion -> 1, 1D),
  BARRIER(protocolVersion -> {
    // Useful resources:
    // - https://github.com/PrismarineJS/minecraft-data/blob/master/data/pc/
@@ -79,11 +80,14 @@ public enum BlockType {
      case MINECRAFT_1_20_3:
        return 10366;
    }
-  });
+  }, 1D);

-  private final Function<ProtocolVersion, Integer> function;
+  private final Function<ProtocolVersion, Integer> idFunction;
+  // TODO: Implement per-version block heights?
+  @Getter
+  private final double blockHeight;

  public int getId(final @NotNull ProtocolVersion protocolVersion) {
-    return function.apply(protocolVersion);
+    return idFunction.apply(protocolVersion);
  }
 }
Author	SHA1	Message	Date
Jones	4474f44b0a	Release 2.0.26 (#269 )	2024-04-20 10:14:13 +02:00
Jones	b159947d6d	Recode max accounts per IP check (#268 )	2024-04-18 18:39:23 +02:00
Jones	a29dfa15e4	Implement max accounts per IP check on Bukkit (#266 ) * feat(bukkit): add max online per IP check * fix: remove debug message haha lol	2024-04-18 17:57:00 +02:00
Jones	cb9fe75db8	Allow user to manually verify players (#265 ) * feat: add /sonar verified add <ip> <uuid/username> * fix: remove useless and stupid local ip check * fix: use correct translation for add message	2024-04-18 17:55:09 +02:00
Jones	23815351f0	Release 2.0.25 (#261 )	2024-04-07 14:44:06 +02:00
Jones	5a68ea8af6	Restructure dependency management (#260 ) * feat: recode command invocation source system * feat: remove obsolete audience listener on Velocity * fix: invalid console action bar sending when uuid is null * feat: microoptimize InvocationSource#isPlayer * build: recode and restructure dependency management * build(bungee,bukkit): downgrade to adventure-platform 4.3.2 * build(all): minimize JAR (excluding api) * build: fix minimizing breaking kyori adventure * style: mark some api functions as internal as they would require relocating when used * build(bukkit): mark as folia supported * build: recode `build-sonar` task * fix: remove unused/outdated files * chore: I think I was dead when writing this * build(deps): load minimessage and serializer-gson using libby * refactor: remove some duplicate/unnecessary code	2024-04-07 14:38:40 +02:00
Jones	9b54b484fb	Update Russian translations (#259 )	2024-04-05 15:02:45 +02:00
Jones	4fa56f2f3c	Hide blacklist logs during attack (#257 )	2024-04-03 13:11:36 +02:00
Jones	51751584dc	Improve code readability and maintainability (#255 ) * style: add comments explaining certain functions/methods * style: add link to stackoverflow comment explaining memory formatting * style: add some more documentation and explanations to the API * style: improve Discord webhook API readability	2024-04-03 13:04:48 +02:00
Jones	3955f9bc8a	Improve verification limits and state system (#254 ) * fix: fail for disconnecting during verification * chore: update bot check failed message * feat: improve state, failing and blacklist system	2024-04-02 21:20:20 +02:00
Jones	e333162032	Implement vehicle mounting check (#251 ) * fix: recode captcha-on-fail mechanic * feat: remove unnecessary max-ping option * feat: [wip] vehicle check and other improvements * feat: add RemoveEntitiesPacket * fix: RemoveEntitiesPacket for 1.7 * fix: PlayerInputPacket for 1.7 * feat: validate jump and unmount state (but don't fail) * fix: RemoveEntitiesPacket not working on 1.17 * fix: boat entity type being broken on 1.13 * feat: [wip] support all versions (1.13-1.13.2 are broken) * fix: boat entity type for 1.13-1.13.2 * feat: add missing vehicle configurations * fix: wait 10s between each action bar on 1.7 * fix: remove unnecessary flush in KeepAlive * fix: only expect PlayerInput packets when needed	2024-03-30 19:16:27 +01:00
dependabot[bot]	b3a7f4de09	Bump netty-all from 4.1.107.Final to 4.1.108.Final (#248 ) Bumps [io.netty:netty-all](https://github.com/netty/netty) from 4.1.107.Final to 4.1.108.Final. - [Commits](https://github.com/netty/netty/compare/netty-4.1.107.Final...netty-4.1.108.Final) --- updated-dependencies: - dependency-name: io.netty:netty-all dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-03-25 13:45:29 +01:00
dependabot[bot]	5752f1e208	Bump lombok from 1.18.30 to 1.18.32 (#249 ) Bumps [org.projectlombok:lombok](https://github.com/projectlombok/lombok) from 1.18.30 to 1.18.32. - [Changelog](https://github.com/projectlombok/lombok/blob/master/doc/changelog.markdown) - [Commits](https://github.com/projectlombok/lombok/compare/v1.18.30...v1.18.32) --- updated-dependencies: - dependency-name: org.projectlombok:lombok dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-03-25 13:45:16 +01:00
MISHA	1c6ba7050d	Add a missed line to Russian translations (#247 )	2024-03-24 20:55:35 +01:00
MISHA	340d4a225d	Add the missing Russian language in messages (#245 ) * Update ru.yml * Update ru.yml	2024-03-24 20:39:10 +01:00
Jones	475bf28ecf	Release 2.0.24 (#244 )	2024-03-24 20:25:30 +01:00
Jones	9c29753084	Recode map CAPTCHA (#243 ) * feat: implement capja for CAPTCHA generation * feat: implement map color palette for 1.7.2-1.20.4	2024-03-24 20:17:18 +01:00
Jones	f0f5196fbe	Don't drop messages that aren't ByteBufs (#242 )	2024-03-22 14:01:32 +01:00
Jones	d98ce28a59	Implement missing packet limits (#241 )	2024-03-22 13:56:55 +01:00
MISHA	e0d5c67cdf	Fix translation error in the Russian language (#240 )	2024-03-16 11:25:43 +01:00
Jones	65e059368c	Release 2.0.23 (#239 )	2024-03-13 16:15:38 +01:00
dependabot[bot]	b7a031da12	Bump io.github.goooler.shadow from 8.1.5 to 8.1.7 (#238 ) Bumps [io.github.goooler.shadow](https://github.com/Goooler/shadow) from 8.1.5 to 8.1.7. - [Release notes](https://github.com/Goooler/shadow/releases) - [Commits](https://github.com/Goooler/shadow/compare/v8.1.5...v8.1.7) --- updated-dependencies: - dependency-name: io.github.goooler.shadow dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-03-11 19:11:17 +01:00
Jones	e15206a382	Implement CAPTCHA-on-fail option (#237 ) * feat: add option to display a CAPTCHA on fail * fix: remove debug message	2024-03-10 13:11:09 +01:00
Jones	5e4af3053e	Fix local database cache duplicating after reload (#236 )	2024-03-07 20:19:42 +01:00
Jones	7bb231ae0d	Release 2.0.22 (#234 )	2024-03-05 18:07:55 +01:00
Jones	a57dfc4e98	Correctly close database connection (#233 )	2024-03-04 17:29:39 +01:00
Jones	618db4804b	Recode bStats metrics implementation (#232 ) * feat: add verification timing and map captcha timing to bstats charts * fix: use correct char ids for bStats * fix: implement shutdown method to correctly stop certain services * style: small codestyle improvements	2024-03-03 18:31:27 +01:00
Jones	613f793dbf	Relocate database drivers to avoid compatibility issues (#231 )	2024-03-03 10:03:48 +01:00
Jones	40964d431c	Release 2.0.21 (#230 )	2024-03-01 22:58:39 +01:00
Jones	b9deff9c0b	Remove unused protocol ids to avoid exploits (#229 )	2024-03-01 22:55:33 +01:00
Jones	e3f27171cf	Fix NullPointerException (#227 )	2024-03-01 22:50:46 +01:00
Jones	d3601e10fe	Remove pipelines if they are not needed anymore (#226 ) * fix: optimize counting of connections and logins * fix: remove Sonar's pipelines if they aren't needed anymore	2024-03-01 19:25:13 +01:00
Jones	258e425ba1	Use correct packet limits for PluginMessagePacket (#225 )	2024-03-01 17:04:24 +01:00
Jones	915e3f593a	Release 2.0.20 (#224 )	2024-03-01 15:31:01 +01:00
Jones	ef525ce718	Only calculate mitigation stats if webhook is enabled (#223 )	2024-03-01 15:14:52 +01:00
Jones	0fbb71a09f	Also check protocols on BungeeCord servers (#222 )	2024-03-01 14:56:36 +01:00
Jones	6ebe44bad3	Drop connections from unknown protocol versions (#221 )	2024-03-01 14:51:43 +01:00
Jones	153d56eeb4	Implement experimental support for MariaDB (#220 ) * feat: add MariaDB as another db type in the config * fix: make sure to disable logging for unnecessary ORM stuff * fix: use pooled connection source to remove unnecessary reflection * feat: support MariaDB (experimental)	2024-02-29 17:56:58 +01:00
Jones	c214d43b3e	Use correct multiple-byte unit for formatting (#219 )	2024-02-25 12:58:02 +01:00
Jones	f3444de4b8	Optimize codecs by removing unused dimensions (#218 )	2024-02-24 23:18:34 +01:00
Jones	a5bf0947b5	Remove duplicate audience listener (#217 )	2024-02-24 14:29:28 +01:00
Jones	3dd5b345cb	Release 2.0.19 (#216 )	2024-02-23 18:09:17 +01:00
Jones	c7581f51d2	Cache held components' NBT and JSON (#215 ) * feat: cache nbt and serialized json in ComponentHolder * style: small clean up of all files	2024-02-22 19:14:16 +01:00
Jones	d556275bf9	Update the packet classes to include the "Packet" suffix (#214 )	2024-02-22 19:03:25 +01:00
Jones	ac662433db	Bump net.kyori.adventure to 4.16.0 (#213 )	2024-02-22 18:56:49 +01:00
Jones	03cb75bf91	Fix FileNotFoundException (#212 )	2024-02-21 19:56:18 +01:00
micartey	541933d472	Add German translations (#211 ) * feat: german translations * fix: remove/change some outdated yaml keys	2024-02-21 13:58:59 +01:00
Jones	8336279136	Fix Discord webhook embed new lines not working (#210 )	2024-02-20 15:39:59 +01:00
MISHA	ea9e53a350	Correct Russian language in messages (#206 ) * correct russian language * to look like original style	2024-02-19 20:35:06 +01:00
Jones	0477a574e2	Use a shared channel handler for Fallback (#209 )	2024-02-19 20:32:38 +01:00
Jones	c8cdba4504	Recode Sonar's statistics system (#208 ) * feat(all): completely recode statistics system * fix(api): remove unused message translations	2024-02-19 20:24:22 +01:00
Jones	83dbfcb8a8	Completely recode component handling logic (#207 ) * feat(all): completely recode component handling logic * fix: the channel is always closed/unusable if there's no decoder	2024-02-19 20:05:00 +01:00
dependabot[bot]	5b62396f9b	Bump netty-all from 4.1.106.Final to 4.1.107.Final (#203 ) Bumps [io.netty:netty-all](https://github.com/netty/netty) from 4.1.106.Final to 4.1.107.Final. - [Commits](https://github.com/netty/netty/compare/netty-4.1.106.Final...netty-4.1.107.Final) --- updated-dependencies: - dependency-name: io.netty:netty-all dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-02-19 13:50:20 +01:00
Jones	23a472d3aa	Release 2.0.18 (#202 )	2024-02-18 16:26:17 +01:00
Jones	76f0f4abda	Recode and optimize bandwidth counting (#201 ) * feat: optimize bandwidth counting by recoding the channel handler * fix: verification breaking new connections if disabled * fix: add exception handlers to ensure that no error can reach the server	2024-02-18 16:16:11 +01:00
Jones	720e1cb1cb	Fix incompatibility with Velocity 3.3.0 b360+ (#200 )	2024-02-18 14:48:09 +01:00
Jones	a98d9337c7	Fully recode injection system (#199 ) * feat(all): fully recode injection technique * fix: issues with proxy protocol enabled	2024-02-17 20:25:19 +01:00
Jones	5158111edf	Implement automatic language system (#197 ) * feat: [wip] better configuration system and better migration system * feat: [wip] French translations for config.yml and webhook.yml * fix(api): improve error handling if the config is invalid * feat: implement better language detection system * feat: allow user control over languages * chore: use config logger in other config-related classes as well * fix: only load MySQL driver if database is being used * refactor: database url -> database host * feat: [wip] add Russian translations for config & webhook (credits to @Nullmx/"nullme" on Discord) * feat: [wip] add Czech translations for config & webhook (credits to @slosa) * feat: [wip] add Georgian translations for config & webhook (credits to @Chumb3x) * fix: missing Georgian translation in config/ka.yml * feat: add Russian messages translation (credits to @Nullmx) * feat: [wip] add Turkish translation for messages.yml (thanks to @AyazJenkins) * fix: MySQL driver not being loaded correctly * fix: some API calls not working because of caffeine * feat: warn about translations not changing configured values	2024-02-17 16:50:17 +01:00
Jones	2ab829b43e	Outline API methods and remove duplicate code (#193 )	2024-02-10 20:45:43 +01:00
Jones	04bbfde6b6	Improve collision checks (#192 ) * fix(api): edit misleading comment in configuration * fix: make client brand check toggleable * fix: only send abilities if needed * feat: allow teleport ids to be negative * fix(fallback): add a little randomization to spawn y position * refactor: move map captcha packet handling to different method * fix: actually fix 1.7 collisions properly * feat: implement another simple and strict collision check * feat: allow more control over the verification steps * fix(api): hide verification failed logs during attacks if enabled	2024-02-10 19:47:42 +01:00
Jones	ef8abcec46	Release 2.0.17 (#191 )	2024-02-10 11:23:13 +01:00
Jones	1fb38ec8d4	Revert `343d71d18c` (#190 )	2024-02-10 00:14:02 +01:00
Jones	cc5e958e2a	Fix issues with the Geyser standalone proxy (#189 )	2024-02-09 21:48:02 +01:00
Jones	1437204a15	Fix incompatibility with Velocity builds 347+ (#188 )	2024-02-08 17:54:52 +01:00
Jones	c96d733920	Use Caffeine cache for blacklist threshold (#187 )	2024-02-07 10:29:22 +01:00
Jones	c561b3eeaf	Fix command delay not working correctly (#186 )	2024-02-07 09:13:30 +01:00
Jones	2310864816	Remove deprecated API functions (#185 )	2024-02-06 18:41:44 +01:00
Jones	55030c5073	Make blacklist time configurable (#184 ) * feat: allow user to customize/configure blacklist time * feat: implement customizable blacklist threshold * feat: use caffeine for caching	2024-02-05 15:38:44 +01:00
Jones	18bb9557b1	Release 2.0.16 (#183 )	2024-01-28 15:00:42 +01:00
Jones	5d02050815	Load Sonar after some other plugins for compatibility (#182 )	2024-01-26 15:06:29 +01:00
Jones	5914b23ae5	Fix relocations breaking dynamic library loading (#180 )	2024-01-26 14:58:23 +01:00
Jones	7ce56a79ab	Remove unused relocations (#178 )	2024-01-25 21:39:51 +01:00
Jones	7b17ba7e53	Bump adventure-platform to 4.3.2 (#177 )	2024-01-25 20:24:10 +01:00
AkkariinandMichel Elkenwaat	8268cda660	Recode packet handling on BungeeCord (#174 ) * feat: switch to HandlerBoss instead of using InitialHandler. * feat: recode channel wrapper initialization structure * fix: remove unnecessary/duplicate methods * fix: update initial BungeeCord methods (check upstream) --------- Co-authored-by: Michel Elkenwaat <admin@jonesdev.xyz>	2024-01-25 19:28:37 +01:00
Jones	89d0c7346f	Use scheduler instead of custom threads for services (#176 ) * fix(bungee): kyori title being broken on BungeeCord * fix(all): use server's scheduler instead of own services * fix(velocity): tasks not being scheduled correctly * fix(velocity): too-many-online-per-IP check breaking on 1.20.2+	2024-01-23 19:36:59 +01:00
Jones	512faa956e	Fix protocol check not using the correct disconnect method (#168 ) Related to https://github.com/jonesdevelopment/sonar/issues/167	2024-01-22 21:12:02 +01:00
Jones	1f6781aaa3	Load all libraries dynamically during runtime (#166 ) * feat: use libby for dynamic dependency loading * fix: MySQL driver not working with new library loading * style: remove debug messages * style: make setup and invoke void static	2024-01-22 20:35:22 +01:00
Jones	bf40333de5	Fix incompatibility with LibreLogin on BungeeCord (#164 )	2024-01-22 14:41:23 +01:00
dependabot[bot]	31b961b577	Bump netty-all from 4.1.104.Final to 4.1.106.Final (#162 ) Bumps [io.netty:netty-all](https://github.com/netty/netty) from 4.1.104.Final to 4.1.106.Final. - [Commits](https://github.com/netty/netty/compare/netty-4.1.104.Final...netty-4.1.106.Final) --- updated-dependencies: - dependency-name: io.netty:netty-all dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-01-22 13:52:22 +01:00
Jones	e4821781fa	Make /sonar notify only executable by players (#161 )	2024-01-21 15:05:23 +01:00
Jones	bdcb7d28a7	Fix broken disconnect packets during login on 1.20.2+ (#160 )	2024-01-21 14:51:05 +01:00
Jones	433fab10f1	Implement chat and title attack notifications (#158 ) * feat: move audiences outside the verbose handler * build(deps): only relocate audience class instead of package * feat: implement chat and title notifications * feat: allow chat notifications to contain traffic	2024-01-21 14:44:52 +01:00
Jones	014b956f9e	Fix compiler errors since Velocity 3.3.0-329 (#157 )	2024-01-20 11:42:27 +01:00
Jones	4be1a970d0	Remove some duplicate code in the API (#156 ) * fix(api): remove duplicate code in FallbackUser * style(api): schedule FallbackUser#disconnect(String) for removal	2024-01-16 17:19:19 +01:00
Jones	bea1d292ee	Release 2.0.15 (#154 )	2024-01-11 18:30:20 +01:00
Jones	468a11e0be	Fix Geyser profiles by reverting parts of the new injection (#153 ) * fix: check for Geyser by using the port instead of channel attribute * feat: revert some of https://github.com/jonesdevelopment/sonar/commit/a66f60f1773ab517ec786ba264313f0d0ad7ed76 to fix https://github.com/jonesdevelopment/sonar/issues/152	2024-01-11 18:21:38 +01:00
Jones	cf2fce9c29	Run DB cleaning and caching in the same thread (#151 )	2024-01-07 17:22:35 +01:00
Jones	cc52289500	Release 2.0.14 (#149 )	2024-01-06 14:55:30 +01:00
Jones	ac1f6d616b	Reword and simplify the README (#148 )	2024-01-02 21:26:04 +01:00
Jones	bdd941171e	Use correct security contact email (#147 )	2024-01-02 21:09:25 +01:00
Jones	1e18a29d1e	Update license year to 2023-2024 (#146 )	2024-01-02 18:17:20 +01:00
Jones	5671c2029e	Change default color scheme in messages (#145 )	2024-01-01 23:55:33 +01:00
Jones	32aeee4f06	Fix license link in README (#144 )	2023-12-31 18:10:28 +01:00
Jones	7b5ce41420	Show server uptime in statistics (#143 ) * style: small code clean up * feat: add server uptime to statistics	2023-12-30 21:44:16 +01:00
Jones	a66f60f177	Recode Velocity injection (#142 ) * feat(bungee): implement empty hostname check * feat: recode Velocity injection * feat: recode action bar counters * fix(bungee): make sure the connection is open	2023-12-30 21:24:53 +01:00
Jones	326a1ecc07	Release 2.0.13 (#140 )	2023-12-30 15:57:53 +01:00
Jones	6af5a9fc4b	Make sure the workflow uses Java 17 (#139 )	2023-12-30 01:17:55 +01:00
Jones	ac78d88721	Bump Velocity API from 3.2.0 to 3.3.0 (#138 )	2023-12-30 01:12:27 +01:00
Jones	75abebde7c	Release 2.0.12 (#136 )	2023-12-25 14:24:08 +01:00
Jones	28b1615b78	Implement maximum age to verified players in database (#134 )	2023-12-21 22:27:26 +01:00
Jones	600275669b	Bump gradle from 8.4 to 8.5 (#133 )	2023-12-20 14:41:21 +01:00
Jones	0c3761be11	Fix event priorities for some event listeners (#132 ) * fix(bungee): use highest event priority for audience listener * fix(bungee): use lowest event priority for fallback listener * fix(bukkit): use highest event priority for audience listener	2023-12-19 16:36:13 +01:00
Jones	b7d8ec74d0	Bump adventure from 4.14.0 to 4.15.0 (#131 )	2023-12-19 16:26:24 +01:00
dependabot[bot]	96efa574e0	Bump netty-all from 4.1.101.Final to 4.1.104.Final (#130 ) Bumps [io.netty:netty-all](https://github.com/netty/netty) from 4.1.101.Final to 4.1.104.Final. - [Commits](https://github.com/netty/netty/compare/netty-4.1.101.Final...netty-4.1.104.Final) --- updated-dependencies: - dependency-name: io.netty:netty-all dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-12-19 15:49:58 +01:00
Jones	8db3d0257f	Release 2.0.11 (#129 )	2023-12-17 14:50:36 +01:00
Jones	106a44f78a	Recode map captcha so it's harder for AI to solve (#128 ) * feat: make map captcha harder for AI to solve * feat: make distortions configurable * fix: use correct distortions factor dividor * fix: memory issues with map precomputing/preparing * fix: characters sometimes ended up out of the frame * fix: don't randomize x position of the character * fix: font size issue * feat: optimize FallbackChannelHandler * feat: make captcha timing configurable * fix: 1.7 and 1.8 clients dying because of my stupidity	2023-12-17 14:47:42 +01:00
Jones	a5872f1b6e	Fix Chat packet using the wrong packet id in 1.20.2 (#127 )	2023-12-15 17:54:22 +01:00