Release 2.0.22 (#234)

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

* fix: use correct char ids for bStats

* fix: implement shutdown method to correctly stop certain services

* style: small codestyle improvements

.github/README.md

@@ -41,12 +41,8 @@
 
 - [Fallback](https://github.com/jonesdevelopment/sonar#fallback) is Sonar's main anti-bot component
 - Sonar queues new player logins to prevent spam login attacks
-- Protective components only on BungeeCord:
-  - Sonar checks the handshake packets for legitimacy
-  - Sonar validates the login/server ping packets
-  - Sonar handles all server pings asynchronously
-  - The Varint decoder is updated to Velocity's
-    improved [MinecraftVarintFrameDecoder](https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/netty/MinecraftVarintFrameDecoder.java).
+- Sonar checks the handshake packets for legitimacy
+- Sonar makes sure some packets cannot be duplicated illegitimately
 
 ### Fallback
 

.gitignore

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

build.gradle.kts

@@ -6,7 +6,7 @@ buildscript {
 
 plugins {
   id("java")
-  id("com.github.johnrengelman.shadow") version "8.1.1"
+  id("io.github.goooler.shadow") version "8.1.5"
   id("io.toolebox.git-versioner") version "1.6.7"
 }
 
@@ -21,13 +21,12 @@ 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")
@@ -36,18 +35,14 @@ allprojects {
     testCompileOnly("org.projectlombok:lombok:1.18.30")
     testAnnotationProcessor("org.projectlombok:lombok:1.18.30")
 
-    val adventureVersion = "4.15.0"
-
     // adventure
-    implementation("net.kyori:adventure-text-minimessage:$adventureVersion")
-    implementation("net.kyori:adventure-text-serializer-gson:$adventureVersion")
-    // adventure nbt
-    implementation("net.kyori:adventure-nbt:$adventureVersion")
+    implementation("net.kyori:adventure-text-minimessage:4.16.0")
+    implementation("net.kyori:adventure-text-serializer-gson:4.16.0")
+    implementation("net.kyori:adventure-nbt:4.16.0")
 
     compileOnly("com.j256.ormlite:ormlite-jdbc:6.1") // ORMLite
-    implementation("xyz.jonesdev:cappuccino:0.1.6-SNAPSHOT") // expiring cache
-
-    compileOnly("io.netty:netty-all:4.1.106.Final") // netty
+    compileOnly("com.github.ben-manes.caffeine:caffeine:3.1.8") // caching
+    compileOnly("io.netty:netty-all:4.1.107.Final") // netty
 
     // Library/dependency loading
     compileOnly("com.alessiodp.libby:libby-core:2.0.0-SNAPSHOT")
@@ -73,36 +68,33 @@ tasks {
 
   shadowJar {
     // Set the file name of the shadowed jar
-    archiveFileName.set("Sonar.jar")
+    archiveFileName.set("${rootProject.name}.jar")
 
     // Remove file timestamps
     isPreserveFileTimestamps = false
 
-    // bStats has to be relocated to the Sonar package otherwise it throws an exception
-    // https://github.com/Bastian/bstats-metrics/blob/master/base/src/main/java/org/bstats/MetricsBase.java#L251
+    // Relocate libraries
     relocate("org.bstats", "xyz.jonesdev.sonar.libs.bstats")
-
-    // https://github.com/jonesdevelopment/sonar/issues/46
-    // Relocate some packages, so we don't run into issues where we accidentally use Velocity's classes
     relocate("com.alessiodp.libby", "xyz.jonesdev.sonar.libs.libby")
-    relocate("xyz.jonesdev.cappuccino", "xyz.jonesdev.sonar.libs.cappuccino")
+    relocate("com.simpleyaml", "xyz.jonesdev.sonar.libs.yaml")
+    relocate("com.google.gson", "xyz.jonesdev.sonar.libs.gson")
+    relocate("com.j256.ormlite", "xyz.jonesdev.sonar.libs.ormlite")
+    relocate("com.github.benmanes.caffeine", "xyz.jonesdev.sonar.libs.caffeine")
+    relocate("com.mysql", "xyz.jonesdev.sonar.libs.mysql")
+    relocate("org.mariadb", "xyz.jonesdev.sonar.libs.mariadb")
+
+    // TODO: actually fix this :/
     // We have to be careful here, so we don't accidentally break adventure
-    relocate("net.kyori.adventure", "xyz.jonesdev.sonar.libs.adventure") {
+    relocate("net.kyori", "xyz.jonesdev.sonar.libs.kyori") {
       exclude("net.kyori.adventure.text.**")
       exclude("net.kyori.adventure.audience.Audience")
       exclude("net.kyori.adventure.title.*")
     }
-    relocate("net.kyori.examination", "xyz.jonesdev.sonar.libs.examination")
-    relocate("net.kyori.option", "xyz.jonesdev.sonar.libs.option")
-    // Relocate dynamically loaded libraries
-    relocate("com.simpleyaml", "xyz.jonesdev.sonar.libs.yaml")
-    relocate("com.google.code.gson", "xyz.jonesdev.sonar.libs.gson")
-    relocate("com.j256.ormlite", "xyz.jonesdev.sonar.libs.ormlite")
-    // We want to load our own Gson dynamically
-    exclude("com/google/gson/**")
 
     // Exclude unnecessary metadata information
-    exclude("META-INF/versions/**")
+    exclude("META-INF/*/**")
+    // We want to load our own Gson dynamically
+    exclude("com/google/gson/**")
   }
 
   compileJava {

gradle.properties

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

gradle/wrapper/gradle-wrapper.properties

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

settings.gradle.kts

@@ -1,4 +1,4 @@
-rootProject.name = "sonar"
+rootProject.name = "Sonar"
 
 sequenceOf("api", "bukkit", "bungee", "common", "velocity").forEach {
   val path = "sonar-$it"

sonar-api/build.gradle.kts

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

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

@@ -17,11 +17,9 @@
 
 package xyz.jonesdev.sonar.api;
 
-import com.alessiodp.libby.LibraryManager;
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
 import net.kyori.adventure.audience.Audience;
 import org.jetbrains.annotations.NotNull;
+import 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;
@@ -29,28 +27,23 @@ 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.text.DecimalFormat;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+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
    */
-  Map<String, Audience> AUDIENCES = new ConcurrentHashMap<>();
+  @Nullable Audience audience(final @Nullable UUID uniqueId);
 
   /**
    * @return The platform the plugin is being run on
@@ -76,7 +69,7 @@ public interface Sonar {
 
   @NotNull SystemTimer getLaunchTimer();
 
-  @NotNull LibraryManager getLibraryManager();
+  @NotNull SonarStatistics getStatistics();
 
   /**
    * Set a custom verbose handler

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

@@ -23,16 +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.Counters;
-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;
@@ -43,8 +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 int peakConnectionsPerSecond;
+    private long peakJoinsPerSecond;
+    private long peakConnectionsPerSecond;
     private double peakProcessCPUUsage;
     private long peakProcessMemoryUsage;
     // Calculate during-attack-statistics using their deltas
@@ -52,7 +51,7 @@ public final class AttackTracker implements JVMProfiler {
   }
 
   public void checkIfUnderAttack() {
-    final int joinsPerSecond = Counters.LOGINS_PER_SECOND.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();
@@ -67,7 +66,7 @@ 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 {
@@ -80,7 +79,7 @@ public final class AttackTracker implements JVMProfiler {
         // Update joins per second peak if necessary
         currentAttack.peakJoinsPerSecond = joinsPerSecond;
       }
-      final int connectionsPerSecond = Counters.CONNECTIONS_PER_SECOND.estimatedSize();
+      final long connectionsPerSecond = Sonar.get().getStatistics().getConnectionsPerSecond();
       if (connectionsPerSecond > currentAttack.peakConnectionsPerSecond) {
         // Update connections per second peak if necessary
         currentAttack.peakConnectionsPerSecond = connectionsPerSecond;
@@ -102,41 +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 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().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("%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());
-          }));
+          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

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

@@ -23,12 +23,13 @@ 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;
+  private final UUID uuid;
   private final Audience audience;
   private final boolean player;
   private final Predicate<String> permissionFunction;

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

@@ -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) {

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

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

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

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

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

@@ -19,7 +19,7 @@ package xyz.jonesdev.sonar.api.controller;
 
 import com.j256.ormlite.dao.Dao;
 import com.j256.ormlite.dao.DaoManager;
-import com.j256.ormlite.jdbc.JdbcSingleConnectionSource;
+import com.j256.ormlite.jdbc.JdbcPooledConnectionSource;
 import com.j256.ormlite.stmt.QueryBuilder;
 import com.j256.ormlite.support.ConnectionSource;
 import com.j256.ormlite.table.TableUtils;
@@ -29,11 +29,12 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.Range;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
+import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
 import xyz.jonesdev.sonar.api.model.VerifiedPlayer;
 
-import java.lang.reflect.Method;
 import java.net.InetAddress;
-import java.sql.*;
+import java.sql.SQLException;
+import java.sql.Timestamp;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
 import java.util.*;
@@ -45,6 +46,24 @@ public final class VerifiedPlayerController {
   private static final Map<String, Collection<UUID>> MAP = new ConcurrentHashMap<>();
   private static final ExecutorService DB_UPDATE_SERVICE = Executors.newSingleThreadExecutor();
 
+  private static final LoggerWrapper LOGGER = new LoggerWrapper() {
+
+    @Override
+    public void info(final String message, final Object... args) {
+      Sonar.get().getLogger().info("[database] " + message, args);
+    }
+
+    @Override
+    public void warn(final String message, final Object... args) {
+      Sonar.get().getLogger().warn("[database] " + message, args);
+    }
+
+    @Override
+    public void error(final String message, final Object... args) {
+      Sonar.get().getLogger().error("[database] " + message, args);
+    }
+  };
+
   private @Nullable ConnectionSource connectionSource;
   private Dao<VerifiedPlayer, Integer> dao;
   private QueryBuilder<VerifiedPlayer, Integer> queryBuilder;
@@ -52,17 +71,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 = 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 {
@@ -79,83 +105,53 @@ public final class VerifiedPlayerController {
       // Make sure to run the clean task and the caching task in the same thread
       // https://github.com/jonesdevelopment/sonar/issues/150
       DB_UPDATE_SERVICE.execute(() -> {
-        // Make sure to clear all outdated entries first
-        clearOld(Sonar.get().getConfig().getDatabase().getMaximumAge());
-        // Add all entries from the database to the cache
         try {
+          // 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) {
-          Sonar.get().getLogger().error("Could not cache entries: {}", exception);
+          LOGGER.error("Error initializing database: {}", exception);
         }
       });
-    } catch (Throwable throwable) {
-      Sonar.get().getLogger().error("Error setting up database: {}", throwable);
-      throwable.printStackTrace(System.err);
+    } catch (SQLException exception) {
+      LOGGER.error("Error setting up database: {}", exception);
     }
   }
 
   /**
-   * Automatically sets up the database connection using the configured credentials
+   * Closes the connection if instantiated
    */
-  private static @NotNull ConnectionSource setupDriverAndConnect() throws Throwable {
-    final SonarConfiguration.Database database = Sonar.get().getConfig().getDatabase();
-
-    // Prepare the JDBC connection string
-    // TODO: automatically build best connection string for database type
-    final String jdbcURL = String.format("jdbc:%s://%s:%d/%s",
-      database.getType().name().toLowerCase(), database.getUrl(), database.getPort(), database.getName());
-
-    // Use reflection to uncover the driver class
-    final Class<?> driverClass = Class.forName(database.getType().getDriverClassName());
-
-    // Make sure we send the username and password
-    final Properties credentials = new Properties();
-    credentials.put("user", database.getUsername());
-    credentials.put("password", database.getPassword());
-
-    // Return new JDBC connection instance for our controller to handle
-    return new JdbcSingleConnectionSource(jdbcURL, invoke(jdbcURL, driverClass, credentials));
-  }
-
-  /**
-   * Uses reflection to load the database driver from the injected library
-   *
-   * @param connectionString URL of the database
-   * @param driverClass      Class of the database driver
-   * @param credentials      Credentials for the database
-   */
-  private static Connection invoke(final @NotNull String connectionString,
-                                   final @NotNull Class<?> driverClass,
-                                   final @NotNull Properties credentials) throws Throwable {
-    final Object driver = driverClass.getDeclaredConstructor().newInstance();
-    DriverManager.registerDriver((Driver) driver);
-    final Method connect = driverClass.getDeclaredMethod("connect", String.class, Properties.class);
-    connect.setAccessible(true);
-    return (Connection) connect.invoke(driver, connectionString, credentials);
+  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) {
-    try {
-      final long timestamp = Instant.now()
-        .minus(maximumAge, ChronoUnit.DAYS)
-        .getEpochSecond() * 1000L; // convert to ms
+  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();
+    final List<VerifiedPlayer> oldEntries = queryBuilder.where()
+      .lt("timestamp", new Timestamp(timestamp))
+      .query();
 
-      if (oldEntries != null) {
-        for (final VerifiedPlayer player : oldEntries) {
-          dao.delete(player);
-        }
-        Sonar.get().getLogger().info("Removed {} database entries older than {} days.",
-          oldEntries.size(), maximumAge);
+    if (oldEntries != null) {
+      for (final VerifiedPlayer player : oldEntries) {
+        dao.delete(player);
       }
-    } catch (SQLException exception) {
-      Sonar.get().getLogger().error("Error trying to clear old entries: {}", exception);
+      LOGGER.info("Removed {} database entries older than {} days.",
+        oldEntries.size(), maximumAge);
     }
   }
 
@@ -191,7 +187,7 @@ public final class VerifiedPlayerController {
           }
         }
       } catch (SQLException exception) {
-        Sonar.get().getLogger().error("Error trying to remove entry: {}", exception);
+        LOGGER.error("Error trying to remove entry: {}", exception);
       }
     });
   }
@@ -229,7 +225,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);
       }
     });
   }
@@ -273,7 +269,7 @@ public final class VerifiedPlayerController {
         dao.deleteBuilder().delete();
       }
     } catch (SQLException exception) {
-      Sonar.get().getLogger().error("Error trying to clear entries: {}", exception);
+      LOGGER.error("Error trying to clear entries: {}", exception);
     }
   }
 

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

@@ -31,5 +31,5 @@ import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 @RequiredArgsConstructor
 public final class UserBlacklistedEvent implements SonarEvent {
   @ApiStatus.Experimental
-  private final FallbackUser<?> user;
+  private final FallbackUser user;
 }

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

@@ -30,11 +30,11 @@ import java.util.Optional;
 @ToString
 @EqualsAndHashCode
 public final class UserVerifyFailedEvent implements SonarEvent {
-  private final FallbackUser<?> user;
+  private final FallbackUser user;
   @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
   private final Optional<String> reason;
 
-  public UserVerifyFailedEvent(final FallbackUser<?> user, final @Nullable String reason) {
+  public UserVerifyFailedEvent(final FallbackUser user, final @Nullable String reason) {
     this.user = user;
     this.reason = Optional.ofNullable(reason);
   }

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

@@ -30,5 +30,5 @@ import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 @RequiredArgsConstructor
 public final class UserVerifyJoinEvent implements SonarEvent {
   private final String username;
-  private final FallbackUser<?> user;
+  private final FallbackUser user;
 }

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

@@ -33,6 +33,6 @@ import java.util.UUID;
 public final class UserVerifySuccessEvent implements SonarEvent {
   private final String username;
   private final UUID offlineUuid;
-  private final FallbackUser<?> user;
+  private final FallbackUser user;
   private final long timeTakenToVerify;
 }

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

@@ -17,12 +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.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;
@@ -31,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)
@@ -39,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;
 

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

@@ -21,6 +21,5 @@ public interface FallbackPipelines {
   String FALLBACK_HANDLER = "sonar-fallback-handler";
   String FALLBACK_PACKET_ENCODER = "sonar-fallback-encoder";
   String FALLBACK_PACKET_DECODER = "sonar-fallback-decoder";
-  String FALLBACK_IN_TRAFFIC = "sonar-traffic-in";
-  String FALLBACK_OUT_TRAFFIC = "sonar-traffic-out";
+  String FALLBACK_BANDWIDTH = "sonar-fallback-bandwidth";
 }

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

@@ -30,7 +30,7 @@ import java.util.concurrent.ConcurrentHashMap;
 @Getter
 @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
 public final class FallbackQueue {
-  public static final FallbackQueue INSTANCE = new FallbackQueue();
+  static final FallbackQueue INSTANCE = new FallbackQueue();
   private final Map<InetAddress, Runnable> queuedPlayers = new ConcurrentHashMap<>(64);
 
   // Runnable task executed for polling the queue

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

@@ -17,19 +17,19 @@
 
 package xyz.jonesdev.sonar.api.fallback;
 
+import com.github.benmanes.caffeine.cache.Cache;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.cappuccino.ExpiringCache;
 
 import java.net.InetAddress;
 
+@Setter
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
 public final class FallbackRatelimiter {
-  public static final FallbackRatelimiter INSTANCE = new FallbackRatelimiter();
-  @Setter
-  private ExpiringCache<InetAddress> expiringCache;
+  static final FallbackRatelimiter INSTANCE = new FallbackRatelimiter();
+  private Cache<InetAddress, Byte> expiringCache;
 
   /**
    * We don't want to clean up the cache in the
@@ -37,7 +37,7 @@ public final class FallbackRatelimiter {
    * it would take up too many resources.
    */
   public void cleanUpCache() {
-    expiringCache.cleanUp(false);
+    expiringCache.cleanUp();
   }
 
   /**
@@ -49,9 +49,9 @@ 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 (!expiringCache.asMap().containsKey(inetAddress)) {
       // Cache the IP address
-      expiringCache.put(inetAddress);
+      expiringCache.put(inetAddress, (byte) 0);
       return true;
     }
     // Deny the connection attempt

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

@@ -17,61 +17,49 @@
 
 package xyz.jonesdev.sonar.api.fallback;
 
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
 import io.netty.channel.Channel;
-import io.netty.channel.ChannelPipeline;
 import io.netty.util.ReferenceCountUtil;
 import net.kyori.adventure.text.Component;
-import org.jetbrains.annotations.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<T> {
-  @NotNull Fallback getFallback();
-
-  /**
-   * @return Per-platform connection object used internally
-   */
-  @NotNull T getConnection();
+import java.time.Duration;
+import java.util.Objects;
+import java.util.UUID;
 
+public interface FallbackUser {
   @NotNull Channel getChannel();
 
-  @NotNull ChannelPipeline getPipeline();
-
   @NotNull InetAddress getInetAddress();
 
   @NotNull ProtocolVersion getProtocolVersion();
 
   /**
-   * Kicks the player from the server with
-   * the given disconnect message.
-   *
-   * @param reason Legacy disconnect message string
-   * @see #disconnect(Component)
-   */
-  @Deprecated
-  @ApiStatus.ScheduledForRemoval(inVersion = "2.0.17")
-  default void disconnect(final @NotNull String reason) {
-    disconnect(Component.text(reason));
-  }
-
-  /**
-   * Kicks the player from the server with
-   * the given disconnect message.
+   * Disconnect the player during/after verification
+   * using our custom Disconnect packet.
    *
    * @param reason Disconnect message component
    */
   void disconnect(final @NotNull Component reason);
 
+  /**
+   * Takes over the channel and begins the verification process
+   *
+   * @param username Username of the player
+   * @param uuid     UUID of the player
+   * @param encoder  Name of the encoder pipeline
+   * @param decoder  Name of the decoder pipeline
+   * @param timeout  Name of the read timeout pipeline
+   * @param boss     Name of the main pipeline
+   */
+  void hijack(final @NotNull String username, final @NotNull UUID uuid,
+              final @NotNull String encoder, final @NotNull String decoder,
+              final @NotNull String timeout, final @NotNull String boss);
+
   /**
    * Sends a packet/message to the player
    *
@@ -97,7 +85,39 @@ public interface FallbackUser<T> {
     }
   }
 
-  ExpiringCache<String> PREVIOUS_FAILS = Cappuccino.buildExpiring(3L, TimeUnit.MINUTES);
+  Cache<InetAddress, Integer> GLOBAL_FAIL_COUNT = Caffeine.newBuilder()
+    .expireAfterWrite(Duration.ofMinutes(5)) // expire after 5 minutes
+    .build();
+
+  /**
+   * Increments the number of times this user (by IP address) has failed the verification
+   */
+  default void incrementFails() {
+    final InetAddress inetAddress = Objects.requireNonNull(getInetAddress());
+    final int failCount = getFailedCount();
+    // Make sure to remove the old values from the cache
+    if (failCount > 0) {
+      GLOBAL_FAIL_COUNT.invalidate(inetAddress);
+    }
+    GLOBAL_FAIL_COUNT.put(inetAddress, failCount + 1);
+  }
+
+  /**
+   * @return The number of times this user (by IP address) has failed the verification
+   * @apiNote Returns 0 if no key/value is present in the cache
+   */
+  default int getFailedCount() {
+    // Make sure to clean up the cache before we try to get cached values
+    GLOBAL_FAIL_COUNT.cleanUp();
+    return GLOBAL_FAIL_COUNT.asMap().getOrDefault(Objects.requireNonNull(getInetAddress()), 0);
+  }
+
+  /**
+   * Removes all previously failed verifications
+   */
+  default void invalidateFails() {
+    GLOBAL_FAIL_COUNT.invalidate(Objects.requireNonNull(getInetAddress()));
+  }
 
   /**
    * Disconnects the player who failed the verification
@@ -107,38 +127,5 @@ public interface FallbackUser<T> {
    *
    * @param reason Reason for failing the verification
    */
-  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 @Nullable String reason);
 }

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

@@ -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;
-  }
 }

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

@@ -15,66 +15,67 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.profiler;
+package xyz.jonesdev.sonar.api.jvm;
 
 import com.sun.management.OperatingSystemMXBean;
+import lombok.experimental.UtilityClass;
 
 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'};
+@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'};
 
-  default String formatMemory(final long size) {
+  public String formatMemory(final long size) {
     if (size < 1024L) {
       return size + " B";
     }
     final int group = (63 - Long.numberOfLeadingZeros(size)) / 10;
     final double formattedSize = (double) size / (1L << (group * 10));
     final char unit = MEMORY_UNITS[group - 1];
-    return String.format("%.1f %sB", formattedSize, unit);
+    // https://en.wikipedia.org/wiki/Byte#Multiple-byte_units
+    return String.format("%.1f %siB", formattedSize, unit);
   }
 
-  default int getVirtualCores() {
+  public int getVirtualCores() {
     return RUNTIME.availableProcessors();
   }
 
-  default double getProcessCPUUsage() {
-    return OPERATING_SYSTEM_MX_BEAN.getProcessCpuLoad() * 100;
+  public double getProcessCPUUsage() {
+    return MX.getProcessCpuLoad() * 100;
   }
 
-  default double getAverageProcessCPUUsage() {
+  public double getAverageProcessCPUUsage() {
     return getProcessCPUUsage() / getVirtualCores();
   }
 
-  default double getSystemCPUUsage() {
-    return OPERATING_SYSTEM_MX_BEAN.getSystemCpuLoad() * 100;
+  public double getSystemCPUUsage() {
+    return MX.getSystemCpuLoad() * 100;
   }
 
-  default double getAverageSystemCPUUsage() {
+  public double getAverageSystemCPUUsage() {
     return getSystemCPUUsage() / getVirtualCores();
   }
 
-  default double getSystemLoadAverage() {
-    return OPERATING_SYSTEM_MX_BEAN.getSystemLoadAverage() * 100;
+  public double getSystemLoadAverage() {
+    return MX.getSystemLoadAverage() * 100;
   }
 
-  default long getMaxMemory() {
+  public long getMaxMemory() {
     return RUNTIME.maxMemory();
   }
 
-  default long getTotalMemory() {
+  public long getTotalMemory() {
     return RUNTIME.totalMemory();
   }
 
-  default long getFreeMemory() {
+  public long getFreeMemory() {
     return RUNTIME.freeMemory();
   }
 
-  default long getUsedMemory() {
+  public long getUsedMemory() {
     return getTotalMemory() - getFreeMemory();
   }
 }

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

@@ -15,14 +15,15 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.statistics;
+package xyz.jonesdev.sonar.api.ormlite;
 
-import xyz.jonesdev.cappuccino.Cappuccino;
-import xyz.jonesdev.cappuccino.ExpiringCache;
+import com.j256.ormlite.jdbc.db.MariaDbDatabaseType;
+import org.jetbrains.annotations.NotNull;
 
-import java.util.concurrent.TimeUnit;
+public final class MariaDbDatabaseTypeAdapter extends MariaDbDatabaseType {
 
-public interface Counters {
-  ExpiringCache<Long> LOGINS_PER_SECOND = Cappuccino.buildExpiring(1L, TimeUnit.SECONDS);
-  ExpiringCache<Long> CONNECTIONS_PER_SECOND = Cappuccino.buildExpiring(1L, TimeUnit.SECONDS);
+  @Override
+  protected String @NotNull [] getDriverClassNames() {
+    return new String[]{"xyz.jonesdev.sonar.libs.mariadb.jdbc.Driver"};
+  }
 }

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

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

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

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

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

@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2023-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;
-
-public enum Statistics {
-  TOTAL_TRAFFIC,
-  REAL_TRAFFIC,
-  FAILED_VERIFICATIONS;
-
-  private int val = -1;
-
-  /**
-   * Increments the current value by 1 with the default value of 0
-   *
-   * @see #get(int)
-   * @see #set(int)
-   */
-  public void increment() {
-    increment(0);
-  }
-
-  /**
-   * Increments the current value by 1 with a custom default value
-   *
-   * @see #get(int)
-   * @see #set(int)
-   */
-  public void increment(final int def) {
-    set(get(def) + 1);
-  }
-
-  /**
-   * @return The current value with the default value of 0
-   * @see #get(int)
-   */
-  public int get() {
-    return get(0);
-  }
-
-  /**
-   * @return The current value with a custom default value
-   */
-  public int get(final int def) {
-    return val == -1 ? def : val;
-  }
-
-  /**
-   * Set current value to a new value
-   */
-  public void set(final int value) {
-    val = value;
-  }
-}

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

@@ -24,25 +24,22 @@ import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.title.Title;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.statistics.Counters;
-import xyz.jonesdev.sonar.api.statistics.Statistics;
+import 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;
-import static xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter.INCOMING;
-import static xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter.OUTGOING;
 
 @Getter
-public final class Notification implements Observable, Counters {
-  private final @NotNull Collection<String> subscribers = new Vector<>(0);
+public 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;
-    }
+    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));
@@ -52,25 +49,25 @@ public final class Notification implements Observable, Counters {
     // 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().getBlacklisted().estimatedSize()))
-      .replace("%total-joins%", DECIMAL_FORMAT.format(Statistics.TOTAL_TRAFFIC.get()))
-      .replace("%logins-per-second%", DECIMAL_FORMAT.format(LOGINS_PER_SECOND.estimatedSize()))
-      .replace("%connections-per-second%", DECIMAL_FORMAT.format(CONNECTIONS_PER_SECOND.estimatedSize()))
-      .replace("%verify-total%", DECIMAL_FORMAT.format(Statistics.REAL_TRAFFIC.get()))
-      .replace("%verify-success%",
-        DECIMAL_FORMAT.format(Sonar.get().getVerifiedPlayerController().estimatedSize()))
-      .replace("%verify-failed%", DECIMAL_FORMAT.format(Statistics.FAILED_VERIFICATIONS.get()))
-      .replace("%incoming-traffic%", INCOMING.getCachedSecond())
-      .replace("%outgoing-traffic%", OUTGOING.getCachedSecond())
-      .replace("%incoming-traffic-ttl%", INCOMING.getCachedTtl())
-      .replace("%outgoing-traffic-ttl%", OUTGOING.getCachedTtl()));
+        .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 String subscriber : Sonar.get().getNotificationHandler().getSubscribers()) {
-      final Audience audience = Sonar.AUDIENCES.get(subscriber);
+    for (final UUID subscriber : Sonar.get().getNotificationHandler().getSubscribers()) {
+      final Audience audience = Sonar.get().audience(subscriber);
       if (audience == null) continue;
       audience.showTitle(title);
       audience.sendMessage(chat);

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

@@ -20,29 +20,30 @@ package xyz.jonesdev.sonar.api.verbose;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;
+import java.util.UUID;
 
 public interface Observable {
-  Collection<String> getSubscribers();
+  Collection<UUID> getSubscribers();
 
   /**
-   * @param name Name of the audience
+   * @param uuid UUID of the player
    * @return Whether the audience is subscribed or not
    */
-  default boolean isSubscribed(final @NotNull String name) {
-    return getSubscribers().contains(name);
+  default boolean isSubscribed(final @NotNull UUID uuid) {
+    return getSubscribers().contains(uuid);
   }
 
   /**
-   * @param name Name of the audience to subscribe
+   * @param uuid UUID of the player
    */
-  default void subscribe(final String name) {
-    getSubscribers().add(name);
+  default void subscribe(final UUID uuid) {
+    getSubscribers().add(uuid);
   }
 
   /**
-   * @param name Name of the audience to unsubscribe
+   * @param uuid UUID of the player
    */
-  default void unsubscribe(final String name) {
-    getSubscribers().remove(name);
+  default void unsubscribe(final UUID uuid) {
+    getSubscribers().remove(uuid);
   }
 }

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

@@ -25,44 +25,39 @@ import net.kyori.adventure.text.minimessage.MiniMessage;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.attack.AttackTracker;
-import xyz.jonesdev.sonar.api.profiler.JVMProfiler;
-import xyz.jonesdev.sonar.api.statistics.Counters;
-import xyz.jonesdev.sonar.api.statistics.Statistics;
+import xyz.jonesdev.sonar.api.statistics.SonarStatistics;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
 
 import java.util.Collection;
+import java.util.UUID;
 import java.util.Vector;
 
 import static xyz.jonesdev.sonar.api.Sonar.DECIMAL_FORMAT;
-import static xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter.INCOMING;
-import static xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter.OUTGOING;
+import static xyz.jonesdev.sonar.api.jvm.JVMProcessInformation.*;
 
 @Getter
-public final class Verbose implements Observable, JVMProfiler, Counters {
-  private final @NotNull Collection<String> subscribers = new Vector<>(0);
+public final class Verbose implements Observable {
+  private final @NotNull Collection<UUID> subscribers = new Vector<>(0);
   private int animationIndex;
 
   // Run action bar verbose
   public void update() {
-    // Clean up all blacklisted IPs
-    Sonar.get().getFallback().getBlacklisted().cleanUp(false);
-    // Clean up all counters
-    LOGINS_PER_SECOND.cleanUp(false);
-    CONNECTIONS_PER_SECOND.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 = Sonar.AUDIENCES.get(subscriber);
+    for (final UUID subscriber : subscribers) {
+      final Audience audience = Sonar.get().audience(subscriber);
       if (audience == null) continue;
       audience.sendActionBar(component);
     }
   }
 
   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
@@ -72,19 +67,20 @@ public final class Verbose implements Observable, JVMProfiler, Counters {
         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(LOGINS_PER_SECOND.estimatedSize()))
-      .replace("%connections-per-second%", DECIMAL_FORMAT.format(CONNECTIONS_PER_SECOND.estimatedSize()))
-      .replace("%verify-total%", DECIMAL_FORMAT.format(Statistics.REAL_TRAFFIC.get()))
+        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()))

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

@@ -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;
@@ -36,6 +38,8 @@ import java.util.function.Supplier;
 public final class DiscordWebhook {
   private final String url;
 
+  private static final Gson GSON = new GsonBuilder().disableInnerClassSerialization().create();
+
   private static final ExecutorService HTTP_REQUEST_SERVICE = Executors.newSingleThreadExecutor();
 
   public void post(final Supplier<SonarConfiguration.Webhook.Embed> embed) {
@@ -73,7 +77,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,

sonar-bukkit/build.gradle.kts

@@ -7,7 +7,7 @@ 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")
@@ -44,5 +44,5 @@ dependencies {
   implementation("com.alessiodp.libby:libby-bukkit:2.0.0-SNAPSHOT")
 }
 
-java.sourceCompatibility = JavaVersion.VERSION_1_8
-java.targetCompatibility = JavaVersion.VERSION_1_8
+java.sourceCompatibility = JavaVersion.VERSION_11
+java.targetCompatibility = JavaVersion.VERSION_11

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

@@ -19,18 +19,21 @@ package xyz.jonesdev.sonar.bukkit;
 
 import com.alessiodp.libby.BukkitLibraryManager;
 import lombok.Getter;
+import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.platform.bukkit.BukkitAudiences;
 import org.bstats.bukkit.Metrics;
+import org.bstats.charts.SimplePie;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.SonarPlatform;
-import xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter;
 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.util.Objects;
+import java.util.UUID;
 
 @Getter
 public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
@@ -38,7 +41,7 @@ public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
 
   public SonarBukkit(final @NotNull SonarBukkitPlugin plugin) {
     super(plugin, new BukkitLibraryManager(
-      plugin, plugin.getDataFolder().getName()),
+        plugin, plugin.getDataFolder().getName()),
       plugin.getDataFolder(), SonarPlatform.BUKKIT);
     INSTANCE = this;
   }
@@ -48,6 +51,14 @@ public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
    */
   private final BukkitAudiences bukkitAudiences = BukkitAudiences.create(getPlugin());
 
+  @Override
+  public @NotNull Audience audience(final @Nullable UUID uniqueId) {
+    if (uniqueId == null) {
+      return bukkitAudiences.console();
+    }
+    return bukkitAudiences.player(uniqueId);
+  }
+
   /**
    * Create a wrapper for the plugin logger, so we can use it outside
    * the velocity module.
@@ -72,21 +83,25 @@ 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(),
-      TrafficCounter::reset, 20L, 20L);
+      CachedBandwidthStatistics::reset, 20L, 20L);
 
     // Register queue service
     getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
@@ -96,4 +111,10 @@ public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
     getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
       Sonar.get().getVerboseHandler()::update, 4L, 4L);
   }
+
+  @Override
+  public void disable() {
+    // Make sure to properly shutdown bStats metrics
+    metrics.shutdown();
+  }
 }

sonar-bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/audience/AudienceListener.java

@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2023-2024 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bukkit.audience;
-
-import net.kyori.adventure.audience.Audience;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.bukkit.SonarBukkit;
-
-public final class AudienceListener implements Listener {
-
-  @EventHandler(priority = EventPriority.HIGHEST)
-  public void handle(final @NotNull PlayerJoinEvent event) {
-    final Audience audience = SonarBukkit.INSTANCE.getBukkitAudiences().player(event.getPlayer());
-    Sonar.AUDIENCES.put(event.getPlayer().getName(), audience);
-  }
-
-  @EventHandler(priority = EventPriority.HIGHEST)
-  public void handle(final @NotNull PlayerQuitEvent event) {
-    Sonar.AUDIENCES.remove(event.getPlayer().getName());
-  }
-}

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

@@ -25,7 +25,7 @@ import xyz.jonesdev.sonar.bukkit.SonarBukkit;
 
 public final class BukkitInvocationSource extends InvocationSource {
   public BukkitInvocationSource(final @NotNull CommandSender sender) {
-    super(sender.getName(),
+    super(sender instanceof Player ? ((Player) sender).getUniqueId() : null,
       SonarBukkit.INSTANCE.getBukkitAudiences().sender(sender),
       sender instanceof Player,
       sender::hasPermission);

sonar-bungee/build.gradle.kts

@@ -5,7 +5,7 @@ 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"
@@ -29,5 +29,5 @@ dependencies {
   implementation("com.alessiodp.libby:libby-bungee:2.0.0-SNAPSHOT")
 }
 
-java.sourceCompatibility = JavaVersion.VERSION_1_8
-java.targetCompatibility = JavaVersion.VERSION_1_8
+java.sourceCompatibility = JavaVersion.VERSION_11
+java.targetCompatibility = JavaVersion.VERSION_11

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

@@ -19,20 +19,22 @@ package xyz.jonesdev.sonar.bungee;
 
 import com.alessiodp.libby.BungeeLibraryManager;
 import lombok.Getter;
+import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.platform.bungeecord.BungeeAudiences;
 import org.bstats.bungeecord.Metrics;
+import org.bstats.charts.SimplePie;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.SonarPlatform;
-import xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter;
 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.bungee.fallback.FallbackLoginListener;
 import xyz.jonesdev.sonar.common.boot.SonarBootstrap;
+import xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics;
 
+import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
 @Getter
@@ -49,6 +51,14 @@ public final class SonarBungee extends SonarBootstrap<SonarBungeePlugin> {
    */
   private final BungeeAudiences bungeeAudiences = BungeeAudiences.create(getPlugin());
 
+  @Override
+  public @NotNull Audience audience(final @Nullable UUID uniqueId) {
+    if (uniqueId == null) {
+      return bungeeAudiences.console();
+    }
+    return bungeeAudiences.player(uniqueId);
+  }
+
   /**
    * Create a wrapper for the plugin logger, so we can use it outside
    * the velocity module.
@@ -73,26 +83,27 @@ 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 audience register listener
-    getPlugin().getServer().getPluginManager().registerListener(getPlugin(), new AudienceListener());
-
-    // Inject base into ProtocolUtils
-    BaseInjectionHelper.inject(ChildChannelInitializer.INSTANCE);
+    getPlugin().getServer().getPluginManager().registerListener(getPlugin(), new FallbackLoginListener());
 
     // Register traffic service
-    getPlugin().getServer().getScheduler().schedule(getPlugin(), TrafficCounter::reset,
+    getPlugin().getServer().getScheduler().schedule(getPlugin(), CachedBandwidthStatistics::reset,
       1L, 1L, TimeUnit.SECONDS);
 
     // Register queue service
@@ -102,5 +113,14 @@ public final class SonarBungee extends SonarBootstrap<SonarBungeePlugin> {
     // 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();
   }
 }

sonar-bungee/src/main/java/xyz/jonesdev/sonar/bungee/audience/AudienceListener.java

@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2023-2024 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.audience;
-
-import net.kyori.adventure.audience.Audience;
-import net.md_5.bungee.api.event.PlayerDisconnectEvent;
-import net.md_5.bungee.api.event.PostLoginEvent;
-import net.md_5.bungee.api.plugin.Listener;
-import net.md_5.bungee.event.EventHandler;
-import net.md_5.bungee.event.EventPriority;
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.bungee.SonarBungee;
-
-public final class AudienceListener implements Listener {
-
-  @EventHandler(priority = EventPriority.HIGHEST)
-  public void handle(final @NotNull PostLoginEvent event) {
-    final Audience audience = SonarBungee.INSTANCE.getBungeeAudiences().player(event.getPlayer());
-    Sonar.AUDIENCES.put(event.getPlayer().getName(), audience);
-  }
-
-  @EventHandler(priority = EventPriority.HIGHEST)
-  public void handle(final @NotNull PlayerDisconnectEvent event) {
-    Sonar.AUDIENCES.remove(event.getPlayer().getName());
-  }
-}

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

@@ -25,7 +25,7 @@ import xyz.jonesdev.sonar.bungee.SonarBungee;
 
 public final class BungeeInvocationSource extends InvocationSource {
   public BungeeInvocationSource(final @NotNull CommandSender sender) {
-    super(sender.getName(),
+    super(sender instanceof ProxiedPlayer ? ((ProxiedPlayer) sender).getUniqueId() : null,
       SonarBungee.INSTANCE.getBungeeAudiences().sender(sender),
       sender instanceof ProxiedPlayer,
       sender::hasPermission);

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

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

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

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

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

@@ -1,409 +0,0 @@
-/*
- * Copyright (C) 2023-2024 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.bungee.fallback;
-
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelFutureListener;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelPipeline;
-import io.netty.handler.codec.CorruptedFrameException;
-import io.netty.handler.codec.haproxy.HAProxyMessage;
-import lombok.Getter;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.serializer.json.JSONComponentSerializer;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.EncryptionUtil;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.chat.ComponentSerializer;
-import net.md_5.bungee.connection.DownstreamBridge;
-import net.md_5.bungee.connection.UpstreamBridge;
-import net.md_5.bungee.netty.ChannelWrapper;
-import net.md_5.bungee.netty.HandlerBoss;
-import net.md_5.bungee.netty.PacketHandler;
-import net.md_5.bungee.protocol.PacketWrapper;
-import net.md_5.bungee.protocol.PlayerPublicKey;
-import net.md_5.bungee.protocol.packet.Handshake;
-import net.md_5.bungee.protocol.packet.Kick;
-import net.md_5.bungee.protocol.packet.LoginRequest;
-import net.md_5.bungee.protocol.packet.StatusRequest;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import xyz.jonesdev.sonar.api.ReflectiveOperationException;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.event.impl.UserVerifyJoinEvent;
-import xyz.jonesdev.sonar.api.fallback.Fallback;
-import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
-import xyz.jonesdev.sonar.api.statistics.Counters;
-import xyz.jonesdev.sonar.api.statistics.Statistics;
-import xyz.jonesdev.sonar.common.fallback.FallbackChannelHandler;
-import xyz.jonesdev.sonar.common.fallback.FallbackTimeoutHandler;
-import xyz.jonesdev.sonar.common.fallback.FallbackVerificationHandler;
-import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketDecoder;
-import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketEncoder;
-import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry;
-import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginSuccess;
-import xyz.jonesdev.sonar.common.fallback.traffic.TrafficChannelHooker;
-
-import java.lang.reflect.Field;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.nio.charset.StandardCharsets;
-import java.time.Instant;
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.TimeUnit;
-
-import static net.md_5.bungee.netty.PipelineUtils.*;
-import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.*;
-import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT_1_19_1;
-import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT_1_19_3;
-import static xyz.jonesdev.sonar.common.utility.geyser.GeyserUtil.isGeyserConnection;
-
-public final class FallbackHandlerBoss extends HandlerBoss {
-  private static final @NotNull Fallback FALLBACK = Sonar.get().getFallback();
-  private static final @NotNull BungeeCord BUNGEE = BungeeCord.getInstance();
-
-  private static final Field CHANNEL_WRAPPER_FIELD;
-
-  static {
-    try {
-      CHANNEL_WRAPPER_FIELD = HandlerBoss.class.getDeclaredField("channel");
-      CHANNEL_WRAPPER_FIELD.setAccessible(true);
-    } catch (Exception exception) {
-      throw new ReflectiveOperationException(exception);
-    }
-  }
-
-  private ChannelWrapper channelWrapper;
-  private PacketHandler handler;
-  private @Nullable FallbackUserWrapper user;
-  @Getter
-  private ProtocolVersion protocolVersion;
-  private boolean receivedLoginPacket;
-  private boolean receivedStatusPacket;
-
-  @Override
-  public void setHandler(final @NotNull PacketHandler handler) {
-    this.handler = handler;
-    super.setHandler(handler);
-  }
-
-  @Override
-  public void channelActive(final ChannelHandlerContext ctx) throws Exception {
-    if (handler != null) {
-      super.channelActive(ctx);
-      // Use the same channel wrapper as the "real" HandlerBoss
-      channelWrapper = (ChannelWrapper) CHANNEL_WRAPPER_FIELD.get(this);
-      // Increase connections per second for the action bar verbose
-      Counters.CONNECTIONS_PER_SECOND.put(System.nanoTime());
-    }
-  }
-
-  @Override
-  public void channelRead(final ChannelHandlerContext ctx, final Object msg) throws Exception {
-    if (msg instanceof HAProxyMessage || msg instanceof PacketWrapper) {
-      if (msg instanceof PacketWrapper) {
-        final PacketWrapper packetWrapper = (PacketWrapper) msg;
-        // Handle Handshake packets
-        if (packetWrapper.packet instanceof Handshake) {
-          final Handshake handshake = (Handshake) packetWrapper.packet;
-          // Check if the host is invalid
-          if (handshake.getHost().isEmpty()) {
-            throw new CorruptedFrameException("Hostname is empty");
-          }
-          // Set protocol version
-          protocolVersion = ProtocolVersion.fromId(handshake.getProtocolVersion());
-        }
-        // Handle StatusRequest packets
-        if (packetWrapper.packet instanceof StatusRequest) {
-          // Fix status packet spam exploit
-          if (receivedStatusPacket) {
-            throw new CorruptedFrameException("Duplicate status packet");
-          }
-          receivedStatusPacket = true;
-        }
-        // Handle LoginRequest packets
-        if (packetWrapper.packet instanceof LoginRequest) {
-          final LoginRequest loginRequest = (LoginRequest) packetWrapper.packet;
-
-          // Increase joins per second for the action bar verbose
-          Counters.LOGINS_PER_SECOND.put(System.nanoTime());
-
-          // Fix login packet spam exploit
-          if (receivedLoginPacket || user != null) {
-            throw new CorruptedFrameException("Duplicate login packet");
-          }
-          receivedLoginPacket = true;
-          // Cache protocol version so other handlers don't throw NPEs
-          final Channel channel = channelWrapper.getHandle();
-
-          // Run in the channel's event loop
-          channel.eventLoop().execute(() -> {
-
-            // Do not continue if the connection is closed or marked as disconnected
-            if (channelWrapper.isClosed() || channelWrapper.isClosing()) return;
-
-            try {
-              // Hook the custom traffic pipeline, so we can count the incoming and outgoing traffic
-              final ChannelPipeline pipeline = channel.pipeline();
-              TrafficChannelHooker.hook(pipeline, PACKET_DECODER, PACKET_ENCODER);
-
-              // Increase total traffic statistic
-              Statistics.TOTAL_TRAFFIC.increment();
-
-              // Use the ChannelWrapper's remote address to automatically handle proxy protocol
-              final InetAddress inetAddress = ((InetSocketAddress) channelWrapper.getRemoteAddress()).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.channelRead(ctx, msg);
-                return;
-              }
-
-              // Completely skip Geyser connections
-              if (isGeyserConnection(channel)) {
-                FALLBACK.getLogger().info("Skipping Geyser player: {}{}",
-                  loginRequest.getData(), Sonar.get().getConfig().formatAddress(inetAddress));
-                super.channelRead(ctx, msg);
-                return;
-              }
-
-              // Check if the protocol ID of the player is not allowed to enter the server
-              if (Sonar.get().getConfig().getVerification().getBlacklistedProtocols()
-                .contains(protocolVersion.getProtocol())) {
-                closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getProtocolBlacklisted()));
-                return;
-              }
-
-              final UUID uuid = UUID.nameUUIDFromBytes(("OfflinePlayer:" + loginRequest.getData())
-                .getBytes(StandardCharsets.UTF_8));
-              // Check if the player is already verified
-              if (Sonar.get().getVerifiedPlayerController().has(inetAddress, uuid)) {
-                super.channelRead(ctx, msg);
-                return;
-              }
-
-              // Check if the protocol ID of the player is allowed to bypass verification
-              if (Sonar.get().getConfig().getVerification().getWhitelistedProtocols()
-                .contains(protocolVersion.getProtocol())) {
-                super.channelRead(ctx, msg);
-                return;
-              }
-
-              // Create wrapped Fallback user
-              user = new FallbackUserWrapper(
-                FALLBACK, this, channel, channel.pipeline(),
-                inetAddress, protocolVersion);
-
-              // Perform default BungeeCord checks
-              if (BUNGEE.config.isEnforceSecureProfile()
-                && user.getProtocolVersion().compareTo(MINECRAFT_1_19_3) < 0) {
-                final PlayerPublicKey publicKey = loginRequest.getPublicKey();
-                if (publicKey == null) {
-                  closeWith(getKickPacket(Component.text(BUNGEE.getTranslation("secure_profile_required"))));
-                  return;
-                }
-                if (Instant.ofEpochMilli(publicKey.getExpiry()).isBefore(Instant.now())) {
-                  closeWith(getKickPacket(BUNGEE.getTranslation("secure_profile_expired")));
-                  return;
-                }
-                if (user.getProtocolVersion().compareTo(MINECRAFT_1_19_1) < 0
-                  && !EncryptionUtil.check(publicKey, null)) {
-                  closeWith(getKickPacket(BUNGEE.getTranslation("secure_profile_invalid")));
-                  return;
-                }
-              }
-
-              // Check if the player is already queued since we don't want bots to flood the queue
-              if (FALLBACK.getQueue().getQueuedPlayers().containsKey(inetAddress)) {
-                closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getAlreadyQueued()));
-                return;
-              }
-
-              // Check if Fallback is already verifying a player
-              // → is another player with the same IP address connected to Fallback?
-              if (FALLBACK.getConnected().containsKey(loginRequest.getData())
-                || FALLBACK.getConnected().containsValue(inetAddress)) {
-                closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getAlreadyVerifying()));
-                return;
-              }
-
-              // Check if the IP address is currently being rate-limited
-              if (!FALLBACK.getRatelimiter().attempt(inetAddress)) {
-                closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getTooFastReconnect()));
-                return;
-              }
-
-              // We have to add this pipeline to monitor whenever the client disconnects
-              // to remove them from the list of connected and queued players
-              pipeline.addFirst(FALLBACK_HANDLER, new FallbackChannelHandler(loginRequest.getData(), inetAddress));
-
-              // Queue the connection for further processing
-              FALLBACK.getQueue().queue(inetAddress, () -> channel.eventLoop().execute(() -> {
-
-                // Do not continue if the connection is closed or marked as disconnected
-                if (channelWrapper.isClosed() || channelWrapper.isClosing()) return;
-
-                // Check if the username matches the valid name regex to prevent
-                // UTF-16 names or other types of exploits
-                if (!Sonar.get().getConfig().getVerification().getValidNameRegex().matcher(loginRequest.getData()).matches()) {
-                  closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getInvalidUsername()));
-                  return;
-                }
-
-                // Add better timeout handler to avoid known exploits or issues
-                // We also want to timeout bots quickly to avoid flooding
-                final int readTimeout = Sonar.get().getConfig().getVerification().getReadTimeout();
-                pipeline.replace(TIMEOUT_HANDLER, TIMEOUT_HANDLER,
-                  new FallbackTimeoutHandler(readTimeout, TimeUnit.MILLISECONDS));
-
-                // Disconnect if the protocol version could not be resolved
-                if (user.getProtocolVersion().isUnknown()) {
-                  closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getInvalidProtocol()));
-                  return;
-                }
-
-                // Check if the player is already connected to the proxy but still tries to verify
-                final int limit = BUNGEE.config.getPlayerLimit();
-                if (limit > 0 && BUNGEE.getOnlineCount() >= limit) {
-                  closeWith(getKickPacket(BUNGEE.getTranslation("proxy_full")));
-                  return;
-                } else if (!BUNGEE.getConfig().isOnlineMode() && BUNGEE.getPlayer(loginRequest.getData()) != null) {
-                  closeWith(getKickPacket(Sonar.get().getConfig().getVerification().getAlreadyConnected()));
-                  return;
-                }
-
-                // The player joined the verification
-                Statistics.REAL_TRAFFIC.increment();
-
-                if (Sonar.get().getConfig().getVerification().isLogConnections()) {
-                  // Only log the processing message if the server isn't under attack.
-                  // We let the user override this through the configuration.
-                  if (!Sonar.get().getAttackTracker().isCurrentlyUnderAttack()
-                    || Sonar.get().getConfig().getVerification().isLogDuringAttack()) {
-                    FALLBACK.getLogger().info(Sonar.get().getConfig().getVerification().getConnectLog()
-                      .replace("%name%", loginRequest.getData())
-                      .replace("%ip%", Sonar.get().getConfig().formatAddress(inetAddress))
-                      .replace("%protocol%", String.valueOf(user.getProtocolVersion().getProtocol())));
-                  }
-                }
-
-                // Call the VerifyJoinEvent for external API usage
-                Sonar.get().getEventManager().publish(new UserVerifyJoinEvent(loginRequest.getData(), user));
-
-                // Mark the player as connected → verifying players
-                FALLBACK.getConnected().put(loginRequest.getData(), inetAddress);
-
-                // This sometimes happens when the channel hangs, but the player is still connecting
-                // This also fixes a unique issue with TCPShield and other reverse proxies
-                if (user.getPipeline().get(PACKET_ENCODER) == null
-                  || user.getPipeline().get(PACKET_DECODER) == null) {
-                  channelWrapper.close();
-                  return;
-                }
-
-                // Replace normal encoder to allow custom packets
-                final FallbackPacketEncoder encoder = new FallbackPacketEncoder(user.getProtocolVersion());
-                user.getPipeline().replace(PACKET_ENCODER, FALLBACK_PACKET_ENCODER, encoder);
-
-                // Send LoginSuccess packet to make the client think they are joining the server
-                user.write(new LoginSuccess(loginRequest.getData(), uuid));
-
-                // The LoginSuccess packet has been sent, now we can change the registry state
-                encoder.updateRegistry(user.getProtocolVersion().compareTo(ProtocolVersion.MINECRAFT_1_20_2) >= 0
-                  ? FallbackPacketRegistry.CONFIG : FallbackPacketRegistry.GAME);
-
-                // Replace normal decoder to allow custom packets
-                user.getPipeline().replace(PACKET_DECODER, FALLBACK_PACKET_DECODER,
-                  new FallbackPacketDecoder(user, new FallbackVerificationHandler(user, loginRequest.getData(), uuid)));
-              }));
-            } catch (Throwable throwable) {
-              throw new ReflectiveOperationException(throwable);
-            }
-          });
-          return;
-        }
-      }
-      super.channelRead(ctx, msg);
-    }
-  }
-
-  @Override
-  public void exceptionCaught(final @NotNull ChannelHandlerContext ctx, final Throwable throwable) {
-    if (ctx.channel().isActive()) {
-      if (handler instanceof DownstreamBridge || handler instanceof UpstreamBridge) {
-        try {
-          handler.exception(throwable);
-        } catch (Exception exception) {
-          ProxyServer.getInstance().getLogger().severe(handler + " - exception processing exception: " + exception);
-        }
-      }
-
-      channelWrapper.markClosed();
-      ctx.close();
-    }
-  }
-
-  private static final Map<Component, Kick> CACHED_KICK_PACKETS = new ConcurrentHashMap<>(10);
-
-  public static @NotNull Kick getKickPacket(final @NotNull String reason) {
-    final Component component = Component.text(reason);
-    return getKickPacket(component);
-  }
-
-  public static @NotNull Kick getKickPacket(final @NotNull Component component) {
-    Kick cachedKickPacket = CACHED_KICK_PACKETS.get(component);
-    if (cachedKickPacket == null) {
-      final String serialized = JSONComponentSerializer.json().serialize(component);
-      cachedKickPacket = new Kick(ComponentSerializer.deserialize(serialized));
-      CACHED_KICK_PACKETS.put(component, cachedKickPacket);
-    }
-    return cachedKickPacket;
-  }
-
-  public void closeWith(final Object msg) {
-    closeWith(channelWrapper, protocolVersion, msg);
-  }
-
-  // Mostly taken from Velocity
-  public static void closeWith(final @NotNull ChannelWrapper channelWrapper,
-                               final @NotNull ProtocolVersion protocolVersion,
-                               final @NotNull Object msg) {
-    if (channelWrapper.getHandle().isActive()) {
-      if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_8) < 0
-        && protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_7_2) >= 0) {
-        channelWrapper.getHandle().eventLoop().execute(() -> {
-          channelWrapper.getHandle().config().setAutoRead(false);
-          channelWrapper.getHandle().eventLoop().schedule(() -> {
-            channelWrapper.markClosed();
-            channelWrapper.getHandle().writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
-          }, 250L, TimeUnit.MILLISECONDS);
-        });
-      } else {
-        channelWrapper.markClosed();
-        channelWrapper.getHandle().writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
-      }
-    }
-  }
-}

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

@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.bungee.fallback.injection;
+package xyz.jonesdev.sonar.bungee.fallback;
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelInitializer;
@@ -27,20 +27,27 @@ import xyz.jonesdev.sonar.api.ReflectiveOperationException;
 import java.lang.reflect.Field;
 
 @UtilityClass
-public class BaseInjectionHelper {
-  public void inject(final ChannelInitializer<Channel> childHandler) {
+public class FallbackInjectionHelper {
+  public void inject() {
     try {
       final Field childField = PipelineUtils.class.getField("SERVER_CHILD");
       childField.setAccessible(true);
 
+      // Make sure to store the original channel initializer
+      final ChannelInitializer<Channel> originalInitializer = PipelineUtils.SERVER_CHILD;
+      final ChannelInitializer<Channel> fallbackInitializer = new FallbackChannelInitializer(originalInitializer);
+
       final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
       unsafeField.setAccessible(true);
       final Unsafe unsafe = (Unsafe) unsafeField.get(null);
 
+      // Get the base object (the object containing the field)
       final Object base = unsafe.staticFieldBase(childField);
+      // Get the offset of the static field within its class
       final long offset = unsafe.staticFieldOffset(childField);
 
-      unsafe.putObject(base, offset, childHandler);
+      // Replace the original channel initializer
+      unsafe.putObject(base, offset, fallbackInitializer);
     } catch (Exception exception) {
       throw new ReflectiveOperationException(exception);
     }

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

@@ -19,13 +19,16 @@ package xyz.jonesdev.sonar.bungee.fallback;
 
 import lombok.RequiredArgsConstructor;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
 import net.md_5.bungee.api.connection.PendingConnection;
-import net.md_5.bungee.api.event.LoginEvent;
+import net.md_5.bungee.api.event.PreLoginEvent;
 import net.md_5.bungee.api.plugin.Listener;
+import net.md_5.bungee.chat.ComponentSerializer;
 import net.md_5.bungee.connection.InitialHandler;
 import net.md_5.bungee.event.EventHandler;
 import net.md_5.bungee.event.EventPriority;
 import net.md_5.bungee.netty.ChannelWrapper;
+import net.md_5.bungee.protocol.packet.Kick;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.ReflectiveOperationException;
 import xyz.jonesdev.sonar.api.Sonar;
@@ -36,8 +39,10 @@ import java.lang.reflect.Field;
 import java.net.InetAddress;
 import java.util.Objects;
 
+import static xyz.jonesdev.sonar.common.fallback.FallbackUserWrapper.closeWith;
+
 @RequiredArgsConstructor
-public final class FallbackListener implements Listener {
+public final class FallbackLoginListener implements Listener {
 
   private static final Field CHANNEL_FIELD;
 
@@ -52,26 +57,28 @@ public final class FallbackListener implements Listener {
 
   @SuppressWarnings("deprecation")
   @EventHandler(priority = EventPriority.LOWEST)
-  public void handle(final @NotNull LoginEvent event) throws IllegalAccessException {
-    final InetAddress inetAddress = event.getConnection().getAddress().getAddress();
-
+  public void handle(final @NotNull PreLoginEvent event) throws IllegalAccessException {
     // Check if the number of online players using the same IP address as
     // the connecting player is greater than the configured amount
     final int maxOnlinePerIp = Sonar.get().getConfig().getMaxOnlinePerIp();
+    // Don't do anything if the setting is disabled
+    if (maxOnlinePerIp <= 0) return;
 
-    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 */;
+    final InetAddress inetAddress = event.getConnection().getAddress().getAddress();
 
-      // We use '>=' because the player connecting to the server hasn't joined yet
-      if (onlinePerIp >= maxOnlinePerIp) {
-        final Component component = Sonar.get().getConfig().getTooManyOnlinePerIp();
-        final PendingConnection connection = event.getConnection();
-        FallbackHandlerBoss.closeWith((ChannelWrapper) CHANNEL_FIELD.get(connection),
-          ProtocolVersion.fromId(connection.getVersion()), FallbackHandlerBoss.getKickPacket(component));
-      }
+    final long onlinePerIp = SonarBungee.INSTANCE.getPlugin().getServer().getPlayers().stream()
+      .filter(player -> Objects.equals(player.getAddress().getAddress(), inetAddress))
+      .count()
+      + 1 /* add 1 because the player hasn't been added to the list of online players yet */;
+
+    // We use '>=' because the player connecting to the server hasn't joined yet
+    if (onlinePerIp >= maxOnlinePerIp) {
+      final Component component = Sonar.get().getConfig().getTooManyOnlinePerIp();
+      final String serialized = GsonComponentSerializer.gson().serialize(component);
+      final PendingConnection connection = event.getConnection();
+      closeWith(((ChannelWrapper) CHANNEL_FIELD.get(connection)).getHandle(),
+        ProtocolVersion.fromId(connection.getVersion()),
+        new Kick(ComponentSerializer.deserialize(serialized)));
     }
   }
 }

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

@@ -1,53 +0,0 @@
-/*
- * 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.ChannelPipeline;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import net.kyori.adventure.text.Component;
-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<FallbackHandlerBoss> {
-  private final Fallback fallback;
-  private final FallbackHandlerBoss connection;
-  private final Channel channel;
-  private final ChannelPipeline pipeline;
-  private final InetAddress inetAddress;
-  private final ProtocolVersion protocolVersion;
-
-  /**
-   * Disconnect the player during/after verification
-   * using our custom {@link Disconnect} packet.
-   *
-   * @param reason Disconnect message component
-   */
-  @Override
-  public void disconnect(final @NotNull Component reason) {
-    connection.closeWith(Disconnect.create(reason));
-  }
-}

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

@@ -1,80 +0,0 @@
-/*
- * 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.injection;
-
-import io.netty.buffer.PooledByteBufAllocator;
-import io.netty.channel.*;
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.netty.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);
-    }
-  }
-
-  // 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);
-      // Use TCPNoDelay
-      channel.config().setOption(ChannelOption.TCP_NODELAY, true);
-    } catch (ChannelException exception) {
-      // IP_TOS is not supported (Windows XP / Windows Server 2003)
-    }
-    channel.config().setAllocator(PooledByteBufAllocator.DEFAULT);
-    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());
-  }
-}

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

@@ -1,90 +0,0 @@
-/*
- * 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.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.connection.InitialHandler;
-import net.md_5.bungee.netty.PipelineUtils;
-import net.md_5.bungee.protocol.*;
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.ReflectiveOperationException;
-import xyz.jonesdev.sonar.bungee.fallback.FallbackHandlerBoss;
-
-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);
-    }
-  }
-
-  // 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();
-      return;
-    }
-
-    final ListenerInfo listener = channel.attr(PipelineUtils.LISTENER).get();
-
-    if (BungeeCord.getInstance().getPluginManager().callEvent(new ClientConnectEvent(remoteAddress, listener)).isCancelled()) {
-      channel.close();
-      return;
-    }
-
-    BASE.initChannel(channel);
-    channel.pipeline().addBefore(FRAME_DECODER, LEGACY_DECODER, new LegacyDecoder());
-    channel.pipeline().addAfter(FRAME_DECODER, PACKET_DECODER, new MinecraftDecoder(
-      Protocol.HANDSHAKE, true, BUNGEE.getProtocolVersion()));
-    channel.pipeline().addAfter(FRAME_PREPENDER, PACKET_ENCODER, new MinecraftEncoder(
-      Protocol.HANDSHAKE, true, BUNGEE.getProtocolVersion()));
-    channel.pipeline().addBefore(FRAME_PREPENDER, LEGACY_KICKER, LEGACY_KICK);
-    channel.pipeline().get(FallbackHandlerBoss.class).setHandler(new InitialHandler(BUNGEE, listener));
-
-    if (listener.isProxyProtocol()) {
-      channel.pipeline().addFirst(new HAProxyMessageDecoder());
-    }
-  }
-}

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

@@ -1,92 +0,0 @@
-/*
- * 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.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);
-      }
-    }
-  }
-}

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

@@ -1,63 +0,0 @@
-/*
- * 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.varint;
-
-import io.netty.util.ByteProcessor;
-import lombok.Getter;
-import lombok.ToString;
-
-// Taken from
-// https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/netty/VarintByteDecoder.java
-@Getter
-@ToString
-public final class VarintByteDecoder implements ByteProcessor {
-  private DecoderResult result = DecoderResult.TOO_SMALL;
-  private int readVarInt, bytesRead;
-
-  @Override
-  public boolean process(byte b) throws Exception {
-    if (b == 0 && bytesRead == 0) {
-      result = DecoderResult.RUN_OF_ZEROES;
-      return true;
-    }
-
-    if (result == DecoderResult.RUN_OF_ZEROES) {
-      return false;
-    }
-
-    readVarInt |= (b & 0x7F) << bytesRead++ * 7;
-
-    if (bytesRead > 3) {
-      result = DecoderResult.TOO_BIG;
-      return false;
-    }
-
-    if ((b & 0x80) != 128) {
-      result = DecoderResult.SUCCESS;
-      return false;
-    }
-    return true;
-  }
-
-  public enum DecoderResult {
-    SUCCESS,
-    TOO_SMALL,
-    TOO_BIG,
-    RUN_OF_ZEROES
-  }
-}

sonar-common/build.gradle.kts

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

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

@@ -29,7 +29,6 @@ class LibraryLoader {
     libraryManager.addJitPack();
     libraryManager.loadLibraries(
       // Simple-YAML
-      // TODO: use a different library for config management?
       Library.builder()
         .groupId("com{}github{}Carleslc{}Simple-YAML")
         .artifactId("Simple-Yaml")
@@ -41,7 +40,14 @@ class LibraryLoader {
         .groupId("com{}google{}code{}gson")
         .artifactId("gson")
         .version("2.10.1")
-        .relocate("com{}google{}code{}gson", "xyz{}jonesdev{}sonar{}libs{}gson")
+        .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()
@@ -50,11 +56,19 @@ class LibraryLoader {
         .version("6.1")
         .relocate("com{}j256{}ormlite", "xyz{}jonesdev{}sonar{}libs{}ormlite")
         .build(),
-      // MySQL
+      // MySQL driver
       Library.builder()
         .groupId("com{}mysql")
         .artifactId("mysql-connector-j")
         .version("8.3.0")
+        .relocate("com{}mysql", "xyz{}jonesdev{}sonar{}libs{}mysql")
+        .build(),
+      // MariaDB driver
+      Library.builder()
+        .groupId("org{}mariadb{}jdbc")
+        .artifactId("mariadb-java-client")
+        .version("3.3.3")
+        .relocate("org{}mariadb", "xyz{}jonesdev{}sonar{}libs{}mariadb")
         .build()
     );
   }

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

@@ -18,29 +18,30 @@
 package xyz.jonesdev.sonar.common.boot;
 
 import com.alessiodp.libby.LibraryManager;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.j256.ormlite.logger.Level;
+import com.j256.ormlite.logger.Logger;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.cappuccino.Cappuccino;
-import xyz.jonesdev.cappuccino.ExpiringCache;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.SonarPlatform;
 import xyz.jonesdev.sonar.api.SonarSupplier;
 import xyz.jonesdev.sonar.api.command.subcommand.SubcommandRegistry;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
 import xyz.jonesdev.sonar.api.controller.VerifiedPlayerController;
-import xyz.jonesdev.sonar.api.fallback.FallbackRatelimiter;
+import xyz.jonesdev.sonar.api.statistics.SonarStatistics;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
 import xyz.jonesdev.sonar.api.verbose.Notification;
 import xyz.jonesdev.sonar.api.verbose.Verbose;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
 import xyz.jonesdev.sonar.common.subcommand.SubcommandRegistryHolder;
 import xyz.jonesdev.sonar.common.update.UpdateChecker;
 
 import java.io.File;
-import java.net.InetAddress;
-import java.util.concurrent.TimeUnit;
+import java.time.Duration;
 
 @Getter
 @RequiredArgsConstructor
@@ -54,6 +55,7 @@ public abstract class SonarBootstrap<T> implements Sonar {
   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();
@@ -72,10 +74,13 @@ public abstract class SonarBootstrap<T> implements Sonar {
     this.plugin = plugin;
     this.dataDirectory = dataDirectory;
     this.platform = platform;
+    this.statistics = new GlobalSonarStatistics();
     this.verboseHandler = new Verbose();
     this.notificationHandler = new Notification();
     this.config = new SonarConfiguration(dataDirectory);
     this.subcommandRegistry = new SubcommandRegistryHolder();
+    // Hide unnecessary debug information
+    Logger.setGlobalLogLevel(Level.WARNING);
   }
 
   public final void initialize() {
@@ -119,29 +124,55 @@ public abstract class SonarBootstrap<T> implements Sonar {
     getConfig().load();
 
     // Warn player if they reloaded and changed the database type
-    if (getVerifiedPlayerController() != null
-      && getVerifiedPlayerController().getCachedDatabaseType() != getConfig().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 cache
+    getFallback().getRatelimiter().setExpiringCache(Caffeine.newBuilder()
+      .expireAfterWrite(Duration.ofMillis(getConfig().getVerification().getReconnectDelay()))
+      .build());
+
+    // Update blacklist cache
+    final long blacklistTime = getConfig().getVerification().getBlacklistTime();
+    final boolean blacklistExists = getFallback().getBlacklist() != null;
+    // Make sure the blacklist is only set when we need it to prevent data loss
+    if (!blacklistExists // Make sure we create a new cache if it doesn't exist yet
+      || getFallback().getBlacklistTime() != blacklistTime) {
+      // Create new cache with the configured blacklist time
+      getFallback().setBlacklist(Caffeine.newBuilder()
+        .expireAfterWrite(Duration.ofMillis(getConfig().getVerification().getBlacklistTime()))
+        .build());
+      // Store the new blacklist time, so we don't have to reset the blacklist every reload
+      getFallback().setBlacklistTime(blacklistTime);
+      // Warn the user about changing the expiry of the blacklist values
+      if (blacklistExists) {
+        getLogger().warn("The blacklist has been reset as the duration of entries has changed.");
+      }
+    }
 
     // Reinitialize database controller
+    if (verifiedPlayerController != null) {
+      // Close the old connection first
+      verifiedPlayerController.close();
+    }
     verifiedPlayerController = new VerifiedPlayerController();
   }
 
-  public void shutdown() {
+  public final void shutdown() {
+    // Initialize shutdown process
     getLogger().info("Starting shutdown process...");
-
-    // ...
-
+    // Close database connection
+    verifiedPlayerController.close();
+    // Run the per-platform disable method
+    disable();
+    // Thank the user for using Sonar
     getLogger().info("Successfully shut down. Goodbye!");
   }
+
+  public abstract void disable();
 }

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

@@ -15,30 +15,47 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.common.fallback.traffic;
+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.ChannelOutboundHandlerAdapter;
 import io.netty.channel.ChannelPromise;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter;
+
+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 OutgoingBandwidthEncoder extends ChannelOutboundHandlerAdapter {
-  public static final OutgoingBandwidthEncoder INSTANCE = new OutgoingBandwidthEncoder();
+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 @NotNull ChannelPromise promise) throws Exception {
+                    final ChannelPromise promise) throws Exception {
+    // We can only get the size of a message if it's a ByteBuf
     if (msg instanceof ByteBuf) {
-      TrafficCounter.OUTGOING.increment(((ByteBuf) msg).readableBytes());
+      // Increment the outgoing traffic by the amount of readable bytes
+      OUTGOING.increment(((ByteBuf) msg).readableBytes());
     }
+    // Make sure to let the server handle the rest
     ctx.write(msg, promise);
   }
 }

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

@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2023-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.ChannelHandlerContext;
-import io.netty.channel.ChannelInboundHandlerAdapter;
-import lombok.RequiredArgsConstructor;
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.fallback.Fallback;
-
-import java.net.InetAddress;
-
-@RequiredArgsConstructor
-public final class FallbackChannelHandler extends ChannelInboundHandlerAdapter {
-  private static final @NotNull Fallback FALLBACK = Sonar.get().getFallback();
-  private final @NotNull String username;
-  private final @NotNull InetAddress inetAddress;
-
-  @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(inetAddress);
-    // Make sure other handlers also know we've disconnected
-    ctx.fireChannelUnregistered();
-  }
-}

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

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

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

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

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

@@ -26,6 +26,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.event.impl.UserVerifySuccessEvent;
+import xyz.jonesdev.sonar.api.fallback.Fallback;
 import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 import xyz.jonesdev.sonar.api.model.VerifiedPlayer;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
@@ -33,9 +34,10 @@ import xyz.jonesdev.sonar.common.fallback.protocol.*;
 import xyz.jonesdev.sonar.common.fallback.protocol.map.ItemMapType;
 import xyz.jonesdev.sonar.common.fallback.protocol.map.MapInfoPreparer;
 import xyz.jonesdev.sonar.common.fallback.protocol.map.PreparedMapInfo;
-import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.FinishConfiguration;
-import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginAcknowledged;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.FinishConfigurationPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginAcknowledgedPacket;
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
 import xyz.jonesdev.sonar.common.utility.protocol.ProtocolUtil;
 
 import java.util.Objects;
@@ -43,6 +45,7 @@ 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.protocol.ProtocolVersion.*;
@@ -50,10 +53,11 @@ 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
@@ -62,7 +66,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
   private short expectedTransactionId;
   private int expectedKeepAliveId, expectedTeleportId = -1;
   private int tick, totalReceivedPackets, ignoredMovementTicks;
-  private double posX, posY, posZ, lastY;
+  private double posX, posY, posZ, lastY, spawnYPosition;
   private boolean resolvedClientBrand, resolvedClientSettings;
   private boolean listenForMovements;
 
@@ -87,7 +91,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     SUCCESS
   }
 
-  public FallbackVerificationHandler(final @NotNull FallbackUser<?> user,
+  public FallbackVerificationHandler(final @NotNull FallbackUser user,
                                      final @NotNull String username,
                                      final @NotNull UUID playerUuid) {
     this.user = user;
@@ -121,7 +125,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();
     }
@@ -137,7 +141,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
       // 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));
     }
   }
 
@@ -148,7 +152,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     // 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() {
@@ -172,13 +176,17 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     // 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);
+    // 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,6 +195,13 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
   }
 
   private void sendChunkData() {
+    // If we don't have gravity and captcha enabled, simply finish verification
+    if (!Sonar.get().getConfig().getVerification().getGravity().isEnabled()
+      && !FALLBACK.shouldDoMapCaptcha()) {
+      // Save some work by finishing before sending even more packets
+      finish();
+      return;
+    }
     // Set the state to POSITION to avoid false positives
     // and go on with the flow of the verification.
     state = State.POSITION;
@@ -197,29 +212,27 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     }
     // Teleport player into the fake lobby by sending an empty chunk
     user.delayedWrite(EMPTY_CHUNK_DATA);
-    // Send an UpdateSectionBlocks packet with a platform of blocks
-    // to check if the player collides with the solid platform.
-    user.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();
+      return;
     }
+    // Send an UpdateSectionBlocks packet with a platform of blocks
+    // to check if the player collides with the solid platform.
+    user.delayedWrite(updateSectionBlocks);
+    // Send all packets in one flush
+    user.getChannel().flush();
   }
 
-  private static boolean validateClientLocale(final @SuppressWarnings("unused") @NotNull FallbackUser<?> user,
+  private static boolean validateClientLocale(final @SuppressWarnings("unused") @NotNull FallbackUser user,
                                               final String locale) {
     // Check the client locale by performing a simple regex check on it
     final Pattern pattern = Sonar.get().getConfig().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 +240,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,57 +255,58 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     }
   }
 
+  private void handlePacketDuringCaptcha(final @NotNull FallbackPacket packet) {
+    // Check if the player took too long to enter the captcha
+    final int maxDuration = Sonar.get().getConfig().getVerification().getMap().getMaxDuration();
+    checkFrame(!login.elapsed(maxDuration), "took too long to enter captcha");
+
+    // Handle incoming chat messages
+    if (packet instanceof UniversalChatPacket) {
+      final UniversalChatPacket chat = (UniversalChatPacket) packet;
+      Objects.requireNonNull(captcha);
+      if (!chat.getMessage().equals(captcha.getInfo().getAnswer())) {
+        // Captcha is incorrect
+        checkFrame(captchaTriesLeft-- > 0, "failed captcha too often");
+        user.write(incorrectCaptcha);
+        return;
+      }
+      // Captcha is correct
+      finish();
+      return;
+    }
+
+    // Every second
+    if (actionBar.elapsed(1000L)) {
+      final String actionBarMessage = Sonar.get().getConfig().getVerification().getMap().getEnterCodeActionBar();
+      // Only send action bar if the message is actually supposed to be sent
+      if (!actionBarMessage.isEmpty()) {
+        final String timeLeft = String.format("%.0f", (maxDuration - login.delay()) / 1000D);
+        user.write(new UniversalChatPacket(MiniMessage.miniMessage().deserialize(
+          actionBarMessage.replace("%time-left%", timeLeft)), UniversalChatPacket.GAME_INFO_TYPE));
+        // Make sure to reset the timer
+        actionBar.reset();
+      }
+    }
+
+    // Every 10 seconds
+    if (keepAlive.elapsed(10_000L)) {
+      // Send a KeepAlive packet to prevent timeout
+      user.delayedWrite(CAPTCHA_KEEP_ALIVE);
+      // Send both packets in one flush
+      user.getChannel().flush();
+      // Make sure to reset the timer
+      keepAlive.reset();
+    }
+  }
+
   @Override
   public void handle(final @NotNull FallbackPacket packet) {
     // The player has already been verified, drop all other packets
     if (state == State.SUCCESS) return;
-    // 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");
-
-      // Handle incoming chat messages
-      if (packet instanceof Chat) {
-        final Chat chat = (Chat) packet;
-        Objects.requireNonNull(captcha);
-        if (!chat.getMessage().equals(captcha.getInfo().getAnswer())) {
-          // Captcha is incorrect
-          checkFrame(captchaTriesLeft-- > 0, "failed captcha too often");
-          user.write(incorrectCaptcha);
-          return;
-        }
-        // Captcha is correct
-        finish();
-        return;
-      }
-
-      // Every second
-      if (actionBar.elapsed(1000L)) {
-        final String actionBarMessage = Sonar.get().getConfig().getVerification().getMap().getEnterCodeActionBar();
-        // Only send action bar if the message is actually supposed to be sent
-        if (!actionBarMessage.isEmpty()) {
-          final String timeLeft = String.format("%.0f", (maxDuration - login.delay()) / 1000D);
-          user.write(new Chat(MiniMessage.miniMessage().deserialize(
-            actionBarMessage.replace("%time-left%", timeLeft)), Chat.GAME_INFO_TYPE));
-          // Make sure to reset the timer
-          actionBar.reset();
-        }
-      }
-
-      // Every about 10 seconds
-      if (keepAlive.elapsed(timeout)) {
-        // Send the message again to remind the player
-        user.delayedWrite(enterCodeMessage);
-        // Send a KeepAlive packet to prevent timeout
-        user.delayedWrite(CAPTCHA_KEEP_ALIVE);
-        // Send both packets in one flush
-        user.getChannel().flush();
-        // Make sure to reset the timer
-        keepAlive.reset();
-      }
+      handlePacketDuringCaptcha(packet);
       return;
     }
 
@@ -300,13 +314,11 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     final int maxPackets = Sonar.get().getConfig().getVerification().getMaxLoginPackets() + maxMovementTick;
     checkFrame(++totalReceivedPackets < maxPackets, "too many packets");
 
-    // Check if the time limit has exceeded
-    if (login.elapsed(timeout)) {
-      user.getChannel().close();
-      return;
-    }
+    // Check for timeout since the player could be sending packets but not important ones
+    final long timeout = Sonar.get().getConfig().getVerification().getMaxPing();
+    checkFrame(!login.elapsed(timeout), "time limit exceeded");
 
-    if (packet instanceof LoginAcknowledged) {
+    if (packet instanceof LoginAcknowledgedPacket) {
       // Check if we are currently expecting a LoginAcknowledged packet
       assertState(State.LOGIN_ACK);
 
@@ -314,7 +326,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
       configure();
     }
 
-    if (packet instanceof FinishConfiguration) {
+    if (packet instanceof FinishConfigurationPacket) {
       // Check if we are currently expecting a FinishConfiguration packet
       assertState(State.CONFIGURE);
 
@@ -327,8 +339,8 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
       initialJoinProcess();
     }
 
-    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;
@@ -342,8 +354,8 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
       sendJoinGamePacket();
     }
 
-    if (packet instanceof ClientSettings) {
-      final ClientSettings clientSettings = (ClientSettings) packet;
+    if (packet instanceof ClientSettingsPacket) {
+      final ClientSettingsPacket clientSettings = (ClientSettingsPacket) packet;
 
       // Validate the locale using a regex to filter unwanted characters.
       checkFrame(validateClientLocale(user, clientSettings.getLocale()), "invalid locale");
@@ -357,8 +369,8 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
       resolvedClientSettings = true;
     }
 
-    if (packet instanceof PluginMessage) {
-      final PluginMessage pluginMessage = (PluginMessage) packet;
+    if (packet instanceof PluginMessagePacket) {
+      final PluginMessagePacket pluginMessage = (PluginMessagePacket) packet;
 
       // Only the brand channel is important, drop the rest
       if (pluginMessage.getChannel().equals("MC|Brand")
@@ -374,7 +386,9 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
         checkFrame(pluginMessage.getChannel().equals("MC|Brand") || v1_13, "invalid channel");
 
         // Validate the client branding using a regex to filter unwanted characters.
-        checkFrame(validateClientBrand(user, pluginMessage.content()), "invalid client brand");
+        if (Sonar.get().getConfig().getVerification().getBrand().isEnabled()) {
+          checkFrame(validateClientBrand(user, pluginMessage.content()), "invalid client brand");
+        }
 
         // Clients sometimes mess up the ClientSettings or PluginMessage packet.
         if (state == State.PLUGIN_MESSAGE) {
@@ -387,11 +401,11 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
       }
     }
 
-    if (packet instanceof Transaction) {
+    if (packet instanceof TransactionPacket) {
       // Check if we are currently expecting a Transaction packet
       assertState(State.TRANSACTION);
 
-      final Transaction transaction = (Transaction) packet;
+      final TransactionPacket transaction = (TransactionPacket) packet;
 
       // The transaction should always be accepted
       checkFrame(transaction.isAccepted(), "transaction not accepted?!");
@@ -414,12 +428,12 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
       }
     }
 
-    if (packet instanceof TeleportConfirm) {
+    if (packet instanceof TeleportConfirmPacket) {
       // Check if we are currently expecting a TeleportConfirm packet
       assertState(State.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
@@ -432,18 +446,18 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     }
 
     if (state != State.LOGIN_ACK) {
-      if (packet instanceof Position) {
-        final Position position = (Position) packet;
+      if (packet instanceof PlayerPositionPacket) {
+        final PlayerPositionPacket position = (PlayerPositionPacket) packet;
         handlePositionUpdate(position.getX(), position.getY(), position.getZ(), position.isOnGround());
       }
 
-      if (packet instanceof PositionLook) {
-        final PositionLook position = (PositionLook) packet;
+      if (packet instanceof PlayerPositionLookPacket) {
+        final PlayerPositionLookPacket position = (PlayerPositionLookPacket) packet;
         handlePositionUpdate(position.getX(), position.getY(), position.getZ(), position.isOnGround());
       }
 
-      if (packet instanceof Player) {
-        final Player player = (Player) packet;
+      if (packet instanceof PlayerTickPacket) {
+        final PlayerTickPacket player = (PlayerTickPacket) packet;
         handlePositionUpdate(posX, posY, posZ, player.isOnGround());
       }
     }
@@ -454,7 +468,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     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) {
+      && x == SPAWN_X_POSITION && y == spawnYPosition && z == SPAWN_Z_POSITION) {
       // Reset all values to ensure safety on teleport
       tick = 1;
       posY = -1;
@@ -478,7 +492,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
         listenForMovements = true;
       }
 
-      lastY = dynamicSpawnYPosition;
+      lastY = spawnYPosition;
       return;
     }
 
@@ -493,7 +507,10 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     }
 
     // Calculate the difference between the player's Y coordinate and the expected Y coordinate
-    final double collisionOffsetY = DEFAULT_Y_COLLIDE_POSITION - y;
+    double collisionOffsetY = (DEFAULT_Y_COLLIDE_POSITION + blockType.getBlockHeight()) - y;
+    if (user.getProtocolVersion().compareTo(MINECRAFT_1_8) < 0) {
+      collisionOffsetY += 1.62f; // 1.7 is weird and sends the head position instead of the AABB minY
+    }
 
     // Check if the player is colliding by performing a basic Y offset check.
     // The offset cannot be greater than 0 since the blocks will not let the player fall through them.
@@ -502,15 +519,27 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     if (tick > maxMovementTick) {
       // Log/debug position if enabled in the configuration
       if (Sonar.get().getConfig().getVerification().isDebugXYZPositions()) {
-        user.getFallback().getLogger().info("{}: {}/{}/{} - deltaY: {} - ground: {} - collision: {}",
+        FALLBACK.getLogger().info("{}: {}/{}/{} - deltaY: {} - ground: {} - collision: {}",
           username, x, y, z, deltaY, ground, collisionOffsetY);
       }
 
-      // The player is colliding to blocks, finish verification
-      if (ground) {
+      // If the collision check is disabled, finish verification
+      if (!Sonar.get().getConfig().getVerification().getGravity().isCheckCollisions()) {
         captchaOrFinish();
         return;
       }
+
+      // Perform the collision check
+      if (ground) {
+        // Make sure the player is actually colliding with the blocks and not only spoofing ground
+        checkFrame(collisionOffsetY > -0.03, "illegal collision: " + collisionOffsetY);
+        // The player is colliding to blocks, finish verification
+        captchaOrFinish();
+        return;
+      } else {
+        // Make sure the player is colliding with blocks but is sending an invalid ground state
+        checkFrame(collisionOffsetY != 0, "no ground: " + collisionOffsetY);
+      }
     } else {
       // Check if the player is spoofing the ground state
       checkFrame(!ground, "spoofed ground state");
@@ -525,7 +554,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
 
       // Log/debug position if enabled in the configuration
       if (Sonar.get().getConfig().getVerification().isDebugXYZPositions()) {
-        user.getFallback().getLogger().info("{}: {}/{}/{} - deltaY: {} - prediction: {} - offset: {}",
+        FALLBACK.getLogger().info("{}: {}/{}/{} - deltaY: {} - prediction: {} - offset: {}",
           username, x, y, z, deltaY, predictedY, offsetY);
       }
 
@@ -537,7 +566,7 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
   }
 
   private void captchaOrFinish() {
-    if (user.getFallback().shouldDoMapCaptcha()) {
+    if (FALLBACK.shouldDoMapCaptcha()) {
       if (MapInfoPreparer.getPreparedCAPTCHAs() == 0) {
         // This should not happen, but we have to return if there is no captcha prepared
         user.disconnect(Sonar.get().getConfig().getVerification().getCurrentlyPreparing());
@@ -563,8 +592,8 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
     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,
+      ItemMapType.FILLED_MAP.getId(user.getProtocolVersion()), SetSlotPacket.MAP_NBT));
     // Send random captcha to the player
     captcha = MapInfoPreparer.getRandomCaptcha();
     Objects.requireNonNull(captcha).write(user);
@@ -581,7 +610,8 @@ public final class FallbackVerificationHandler implements FallbackPacketListener
   private void finish() {
     state = State.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,
@@ -594,7 +624,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()));
   }

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

@@ -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;

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

@@ -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,7 @@ 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(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 +171,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 +184,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 +200,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 +213,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 +226,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),
@@ -236,10 +239,10 @@ public enum FallbackPacketRegistry {
         map(0x64, MINECRAFT_1_19_4, false),
         map(0x67, MINECRAFT_1_20_2, false),
         map(0x69, MINECRAFT_1_20_3, false));
-      clientbound.register(GameEvent.class, GameEvent::new,
+      clientbound.register(GameEventPacket.class, GameEventPacket::new,
         map(0x20, MINECRAFT_1_20_3, true));
 
-      serverbound.register(Chat.class, Chat::new,
+      serverbound.register(UniversalChatPacket.class, UniversalChatPacket::new,
         map(0x01, MINECRAFT_1_7_2, false),
         map(0x02, MINECRAFT_1_9, false),
         map(0x03, MINECRAFT_1_12, false),
@@ -248,7 +251,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 +266,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 +277,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 +290,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 +305,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 +322,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 +337,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 +373,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));
         }
       }

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

@@ -24,29 +24,28 @@ 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.packets.config.FinishConfigurationPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.config.RegistryDataPacket;
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;
 
 @UtilityClass
 public class FallbackPreparer {
 
   // 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 FallbackPacket joinGame;
@@ -55,6 +54,14 @@ public class FallbackPreparer {
   // Default Spawn Position
   public FallbackPacket dynamicSpawnPosition;
 
+  // Disconnect messages
+  public FallbackPacket blacklisted;
+  public FallbackPacket alreadyQueued;
+  public FallbackPacket alreadyVerifying;
+  public FallbackPacket reconnectedTooFast;
+  public FallbackPacket protocolBlacklisted;
+  public FallbackPacket invalidUsername;
+
   // Collisions
   public final int BLOCKS_PER_ROW = 8; // 8 * 8 = 64 (protocol maximum)
   public final int SPAWN_X_POSITION = 16 / 2; // middle of the chunk
@@ -62,29 +69,25 @@ 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;
 
   public void prepare() {
-    joinGame = new JoinGame(0,
+    joinGame = new JoinGamePacket(1,
       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 +101,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,23 +112,27 @@ 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);
 
+    // Precompute captcha answers
     if (Sonar.get().getConfig().getVerification().getMap().getTiming() != SonarConfiguration.Verification.Timing.NEVER) {
-      enterCodeMessage = new Chat(Sonar.get().getConfig().getVerification().getMap().getEnterCode());
-      incorrectCaptcha = new Chat(Sonar.get().getConfig().getVerification().getMap().getFailedCaptcha());
+      enterCodeMessage = new UniversalChatPacket(Sonar.get().getConfig().getVerification().getMap().getEnterCode(), UniversalChatPacket.SYSTEM_TYPE);
+      incorrectCaptcha = new UniversalChatPacket(
+        Sonar.get().getConfig().getVerification().getMap().getFailedCaptcha(), UniversalChatPacket.SYSTEM_TYPE);
 
-      // Precompute captcha answers
       MapInfoPreparer.prepare();
     }
   }

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

@@ -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);
   }
 }

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

@@ -61,7 +61,7 @@ public final class DimensionRegistry {
   }
 
   private @NotNull CompoundBinaryTag getCodec(final @NotNull String fileName) {
-    try (final InputStream inputStream = Sonar.class.getResourceAsStream("/codecs/" + fileName)) {
+    try (final InputStream inputStream = Sonar.class.getResourceAsStream("/assets/codecs/" + fileName)) {
       return BinaryTagIO.reader().read(Objects.requireNonNull(inputStream), BinaryTagIO.Compression.GZIP);
     } catch (Throwable throwable) {
       Sonar.get().getLogger().error("Could not load mappings for {}: {}", fileName, throwable);

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

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

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/config/FinishConfigurationPacket.java

@@ -23,7 +23,7 @@ import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
 
 @ToString
-public final class FinishConfiguration implements FallbackPacket {
+public final class FinishConfigurationPacket implements FallbackPacket {
 
   @Override
   public void encode(final ByteBuf byteBuf, final ProtocolVersion protocolVersion) {

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/config/RegistryDataPacket.java

@@ -29,7 +29,7 @@ import static xyz.jonesdev.sonar.common.utility.protocol.ProtocolUtil.writeNamel
 
 @Getter
 @ToString
-public final class RegistryData implements FallbackPacket {
+public final class RegistryDataPacket implements FallbackPacket {
 
   @Override
   public void encode(final @NotNull ByteBuf byteBuf, final ProtocolVersion protocolVersion) {

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/login/LoginAcknowledgedPacket.java

@@ -21,7 +21,7 @@ import io.netty.buffer.ByteBuf;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
 
-public final class LoginAcknowledged implements FallbackPacket {
+public final class LoginAcknowledgedPacket implements FallbackPacket {
 
   @Override
   public void encode(final ByteBuf byteBuf, final ProtocolVersion protocolVersion) {

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/login/LoginSuccessPacket.java

@@ -21,6 +21,7 @@ import io.netty.buffer.ByteBuf;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.ToString;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
@@ -33,9 +34,10 @@ import static xyz.jonesdev.sonar.common.utility.protocol.ProtocolUtil.*;
 import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.writeVarInt;
 
 @Getter
+@ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public final class LoginSuccess implements FallbackPacket {
+public final class LoginSuccessPacket implements FallbackPacket {
   private String username;
   private UUID uuid;
 

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/ChunkDataPacket.java

@@ -36,7 +36,7 @@ import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.writeVarInt;
 @ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public final class EmptyChunkData implements FallbackPacket {
+public final class ChunkDataPacket implements FallbackPacket {
   private int x, z;
 
   private static final byte[] SECTION_BYTES = new byte[]{0, 0, 0, 0, 0, 0, 1, 0};

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/ClientAbilitiesPacket.java

@@ -30,7 +30,7 @@ import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
 @ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public class Abilities implements FallbackPacket {
+public class ClientAbilitiesPacket implements FallbackPacket {
   private int encodedFlags;
   private float flySpeed, walkSpeed;
 

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/ClientSettingsPacket.java

@@ -34,7 +34,7 @@ import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.readVarInt;
 @ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public final class ClientSettings implements FallbackPacket {
+public final class ClientSettingsPacket implements FallbackPacket {
   private String locale;
   private byte viewDistance;
   private int chatVisibility;

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/DefaultSpawnPositionPacket.java

@@ -33,7 +33,7 @@ import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT
 @ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public final class DefaultSpawnPosition implements FallbackPacket {
+public final class DefaultSpawnPositionPacket implements FallbackPacket {
   private int x, y, z;
 
   @Override

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/Disconnect.java

@@ -1,65 +0,0 @@
-/*
- * Copyright (C) 2023-2024 Sonar Contributors
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package xyz.jonesdev.sonar.common.fallback.protocol.packets.play;
-
-import com.google.gson.JsonParser;
-import io.netty.buffer.ByteBuf;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.ToString;
-import net.kyori.adventure.nbt.BinaryTag;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.serializer.json.JSONComponentSerializer;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
-import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
-
-import static xyz.jonesdev.sonar.common.utility.component.ComponentSerializer.serialize;
-import static xyz.jonesdev.sonar.common.utility.protocol.ProtocolUtil.writeNamelessCompoundTag;
-import static xyz.jonesdev.sonar.common.utility.protocol.ProtocolUtil.writeString;
-
-@Getter
-@ToString
-@NoArgsConstructor
-@AllArgsConstructor
-public final class Disconnect implements FallbackPacket {
-  private @Nullable String reason;
-  private BinaryTag binaryTag;
-
-  @Override
-  public void encode(final ByteBuf byteBuf, final @NotNull ProtocolVersion protocolVersion) {
-    if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_20_3) >= 0) {
-      writeNamelessCompoundTag(byteBuf, binaryTag);
-    } else {
-      writeString(byteBuf, reason);
-    }
-  }
-
-  @Override
-  public void decode(final ByteBuf byteBuf, final ProtocolVersion protocolVersion) {
-    throw new UnsupportedOperationException();
-  }
-
-  public static @NotNull Disconnect create(final Component component) {
-    final String serialized = JSONComponentSerializer.json().serialize(component);
-    final BinaryTag binaryTag = serialize(new JsonParser().parse(serialized));
-    return new Disconnect(serialized, binaryTag);
-  }
-}

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/DisconnectPacket.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2023-2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback.protocol.packets.play;
+
+import io.netty.buffer.ByteBuf;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
+import xyz.jonesdev.sonar.common.utility.component.ComponentHolder;
+
+@Getter
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+public final class DisconnectPacket implements FallbackPacket {
+  private @NotNull ComponentHolder componentHolder;
+  private boolean login;
+
+  @Override
+  public void encode(final ByteBuf byteBuf, final @NotNull ProtocolVersion protocolVersion) {
+    componentHolder.write(byteBuf, login ? ProtocolVersion.MINECRAFT_1_20_2 : protocolVersion);
+  }
+
+  @Override
+  public void decode(final ByteBuf byteBuf, final ProtocolVersion protocolVersion) {
+    throw new UnsupportedOperationException();
+  }
+
+  public static @NotNull DisconnectPacket create(final @NotNull Component component,
+                                                 final boolean login) {
+    return new DisconnectPacket(new ComponentHolder(component), login);
+  }
+}

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/GameEventPacket.java

@@ -28,7 +28,7 @@ import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
-public final class GameEvent implements FallbackPacket {
+public final class GameEventPacket implements FallbackPacket {
   private int type;
   private float value;
 

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/JoinGamePacket.java

@@ -35,7 +35,7 @@ import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.writeVarInt;
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
-public final class JoinGame implements FallbackPacket {
+public final class JoinGamePacket implements FallbackPacket {
   private int entityId;
   private int gamemode;
   private long partialHashedSeed;
@@ -57,6 +57,7 @@ public final class JoinGame implements FallbackPacket {
       byteBuf.writeByte(0); // difficulty
       byteBuf.writeByte(0); // max players
       writeString(byteBuf, "flat"); // level type
+      return;
     }
 
     if (protocolVersion.inBetween(MINECRAFT_1_8, MINECRAFT_1_9)) {
@@ -66,6 +67,7 @@ public final class JoinGame implements FallbackPacket {
       byteBuf.writeByte(0); // max players
       writeString(byteBuf, "flat"); // level type
       byteBuf.writeBoolean(reducedDebugInfo);
+      return;
     }
 
     if (protocolVersion.inBetween(MINECRAFT_1_9_1, MINECRAFT_1_13_2)) {
@@ -75,6 +77,7 @@ public final class JoinGame implements FallbackPacket {
       byteBuf.writeByte(0); // max players
       writeString(byteBuf, "flat"); // level type
       byteBuf.writeBoolean(reducedDebugInfo);
+      return;
     }
 
     if (protocolVersion.inBetween(MINECRAFT_1_14, MINECRAFT_1_14_4)) {
@@ -84,6 +87,7 @@ public final class JoinGame implements FallbackPacket {
       writeString(byteBuf, "flat"); // level type
       writeVarInt(byteBuf, viewDistance);
       byteBuf.writeBoolean(reducedDebugInfo);
+      return;
     }
 
     if (protocolVersion.inBetween(MINECRAFT_1_15, MINECRAFT_1_15_2)) {
@@ -95,6 +99,7 @@ public final class JoinGame implements FallbackPacket {
       writeVarInt(byteBuf, viewDistance);
       byteBuf.writeBoolean(reducedDebugInfo);
       byteBuf.writeBoolean(showRespawnScreen);
+      return;
     }
 
     if (protocolVersion.inBetween(MINECRAFT_1_16, MINECRAFT_1_16_1)) {
@@ -111,6 +116,7 @@ public final class JoinGame implements FallbackPacket {
       byteBuf.writeBoolean(showRespawnScreen);
       byteBuf.writeBoolean(false); // debug type
       byteBuf.writeBoolean(false); // flat
+      return;
     }
 
     if (protocolVersion.inBetween(MINECRAFT_1_16_2, MINECRAFT_1_17_1)) {
@@ -128,6 +134,7 @@ public final class JoinGame implements FallbackPacket {
       byteBuf.writeBoolean(showRespawnScreen);
       byteBuf.writeBoolean(false); // debug type
       byteBuf.writeBoolean(false); // flat
+      return;
     }
 
     if (protocolVersion.inBetween(MINECRAFT_1_18, MINECRAFT_1_18_2)) {
@@ -151,6 +158,7 @@ public final class JoinGame implements FallbackPacket {
       byteBuf.writeBoolean(showRespawnScreen);
       byteBuf.writeBoolean(false); // debug type
       byteBuf.writeBoolean(false); // flat
+      return;
     }
 
     if (protocolVersion.inBetween(MINECRAFT_1_19, MINECRAFT_1_19_4)) {
@@ -178,6 +186,7 @@ public final class JoinGame implements FallbackPacket {
       byteBuf.writeBoolean(false); // debug type
       byteBuf.writeBoolean(false); // flat
       byteBuf.writeBoolean(false); // no last death location
+      return;
     }
 
     if (protocolVersion.equals(MINECRAFT_1_20)) {
@@ -198,6 +207,7 @@ public final class JoinGame implements FallbackPacket {
       byteBuf.writeBoolean(false); // flat
       byteBuf.writeBoolean(false); // no last death location
       writeVarInt(byteBuf, 0);
+      return;
     }
 
     if (protocolVersion.compareTo(MINECRAFT_1_20_2) >= 0) {

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/KeepAlivePacket.java

@@ -35,7 +35,7 @@ import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.writeVarInt;
 @ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public final class KeepAlive implements FallbackPacket {
+public final class KeepAlivePacket implements FallbackPacket {
   private long id;
 
   @Override

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/MapDataPacket.java

@@ -33,7 +33,7 @@ import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.writeVarInt;
 @ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public final class MapData implements FallbackPacket {
+public final class MapDataPacket implements FallbackPacket {
   private MapInfo mapInfo;
 
   @Override

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/PlayerPositionLookPacket.java

@@ -33,7 +33,7 @@ import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.writeVarInt;
 @ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public final class PositionLook implements FallbackPacket {
+public final class PlayerPositionLookPacket implements FallbackPacket {
   private double x, y, z;
   private float yaw, pitch;
   private int teleportId;
@@ -42,11 +42,10 @@ public final class PositionLook implements FallbackPacket {
   @Override
   public void decode(final @NotNull ByteBuf byteBuf, final @NotNull ProtocolVersion protocolVersion) {
     x = byteBuf.readDouble();
-    // https://github.com/jonesdevelopment/sonar/issues/20
-    if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_8) < 0) {
-      byteBuf.skipBytes(8);
-    }
     y = byteBuf.readDouble();
+    if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_8) < 0) {
+      y = byteBuf.readDouble(); // Account for weird y positions on 1.7
+    }
     z = byteBuf.readDouble();
     yaw = byteBuf.readFloat();
     pitch = byteBuf.readFloat();

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/PlayerPositionPacket.java

@@ -30,18 +30,17 @@ import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
 @ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public final class Position implements FallbackPacket {
+public final class PlayerPositionPacket implements FallbackPacket {
   private double x, y, z;
   private boolean onGround;
 
   @Override
   public void decode(final @NotNull ByteBuf byteBuf, final @NotNull ProtocolVersion protocolVersion) {
     x = byteBuf.readDouble();
-    // https://github.com/jonesdevelopment/sonar/issues/20
-    if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_8) < 0) {
-      byteBuf.skipBytes(8);
-    }
     y = byteBuf.readDouble();
+    if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_8) < 0) {
+      y = byteBuf.readDouble(); // Account for weird y positions on 1.7
+    }
     z = byteBuf.readDouble();
     onGround = byteBuf.readBoolean();
   }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/PlayerTickPacket.java

@@ -30,7 +30,7 @@ import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
 @ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public final class Player implements FallbackPacket {
+public final class PlayerTickPacket implements FallbackPacket {
   private boolean onGround;
 
   @Override

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/PluginMessagePacket.java

@@ -33,26 +33,26 @@ import static xyz.jonesdev.sonar.common.utility.protocol.ProtocolUtil.*;
 // https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/packet/PluginMessage.java
 @Getter
 @ToString
-public final class PluginMessage extends DeferredByteBufHolder implements FallbackPacket {
+public final class PluginMessagePacket extends DeferredByteBufHolder implements FallbackPacket {
   private String channel;
 
-  public PluginMessage() {
+  public PluginMessagePacket() {
     super(null);
   }
 
   @Override
   public int expectedMinLength(final ByteBuf byteBuf, final ProtocolVersion protocolVersion) {
-    return 8;
+    return 4;
   }
 
   @Override
   public int expectedMaxLength(final ByteBuf byteBuf, final ProtocolVersion protocolVersion) {
-    return 0xfff + 1; // limit packet size to 4096
+    return 0xFFF; // strict size limit
   }
 
   @Override
   public void decode(final ByteBuf byteBuf, final @NotNull ProtocolVersion protocolVersion) {
-    channel = readString(byteBuf);
+    channel = readString(byteBuf, 512);
 
     if (protocolVersion.compareTo(MINECRAFT_1_13) >= 0) {
       channel = transformLegacyToModernChannel(channel);

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/SetSlotPacket.java

@@ -37,7 +37,7 @@ import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.writeVarInt;
 @ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public final class SetSlot implements FallbackPacket {
+public final class SetSlotPacket implements FallbackPacket {
   private int windowId;
   private int slot;
   private int count;

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/TeleportConfirmPacket.java

@@ -31,7 +31,7 @@ import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.readVarInt;
 @ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public final class TeleportConfirm implements FallbackPacket {
+public final class TeleportConfirmPacket implements FallbackPacket {
   private int teleportId;
 
   @Override

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/TransactionPacket.java

@@ -32,7 +32,7 @@ import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT
 @ToString
 @NoArgsConstructor
 @AllArgsConstructor
-public final class Transaction implements FallbackPacket {
+public final class TransactionPacket implements FallbackPacket {
   private int windowId, id;
   private boolean accepted;
 

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/UniversalChatPacket.java

@@ -17,24 +17,21 @@
 
 package xyz.jonesdev.sonar.common.fallback.protocol.packets.play;
 
-import com.google.gson.JsonParser;
 import io.netty.buffer.ByteBuf;
 import io.netty.handler.codec.CorruptedFrameException;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import net.kyori.adventure.nbt.BinaryTag;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.serializer.json.JSONComponentSerializer;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
+import xyz.jonesdev.sonar.common.utility.component.ComponentHolder;
 
 import java.time.Instant;
 import java.util.UUID;
 
 import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.*;
-import static xyz.jonesdev.sonar.common.utility.component.ComponentSerializer.serialize;
 import static xyz.jonesdev.sonar.common.utility.protocol.ProtocolUtil.*;
 import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.readVarInt;
 import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.writeVarInt;
@@ -42,7 +39,7 @@ import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.writeVarInt;
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
-public final class Chat implements FallbackPacket {
+public final class UniversalChatPacket implements FallbackPacket {
   private static final UUID PLACEHOLDER_UUID = new UUID(0L, 0L);
   private static final int DIV_FLOOR = -Math.floorDiv(-20, 8);
 
@@ -50,7 +47,7 @@ public final class Chat implements FallbackPacket {
   public static final byte SYSTEM_TYPE = (byte) 1;
   public static final byte GAME_INFO_TYPE = (byte) 2;
 
-  private Component component;
+  private ComponentHolder componentHolder;
   private String message;
   private byte type;
   private boolean signedPreview;
@@ -61,33 +58,20 @@ public final class Chat implements FallbackPacket {
   private boolean signed;
   private byte[] signature;
 
-  // 1.20.3
-  private BinaryTag nbtMessage;
-
-  // Clientbound LegacyChat
-  public Chat(final Component component) {
-    this(component, SYSTEM_TYPE);
+  public UniversalChatPacket(final @NotNull Component component,
+                             final byte type) {
+    this(new ComponentHolder(component), type);
   }
 
-  // Clientbound LegacyChat
-  public Chat(final Component component, final byte type) {
-    this(component, JSONComponentSerializer.json().serialize(component), type);
-  }
-
-  public Chat(final Component component, final String message, final byte type) {
-    this(component, message, type,
-      false, false, null, null,
-      0L, false, null, serialize(new JsonParser().parse(message)));
+  public UniversalChatPacket(final ComponentHolder componentHolder, final byte type) {
+    this.componentHolder = componentHolder;
+    this.type = type;
   }
 
   @Override
   public void encode(final ByteBuf byteBuf, final @NotNull ProtocolVersion protocolVersion) {
     // Serialized message
-    if (protocolVersion.compareTo(MINECRAFT_1_20_3) >= 0) {
-      writeNamelessCompoundTag(byteBuf, nbtMessage);
-    } else {
-      writeString(byteBuf, message);
-    }
+    componentHolder.write(byteBuf, protocolVersion);
 
     // Type
     if (protocolVersion.compareTo(MINECRAFT_1_19_1) >= 0) {

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/packets/play/UpdateSectionBlocksPacket.java

@@ -35,7 +35,7 @@ import static xyz.jonesdev.sonar.common.utility.protocol.VarIntUtil.writeVarLong
 @NoArgsConstructor
 @AllArgsConstructor
 @ToString(exclude = {"changedBlocks"})
-public final class UpdateSectionBlocks implements FallbackPacket {
+public final class UpdateSectionBlocksPacket implements FallbackPacket {
   private int sectionX, sectionZ;
   private ChangedBlock[] changedBlocks;
 

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/traffic/IncomingBandwidthDecoder.java

@@ -1,42 +0,0 @@
-/*
- * 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.traffic;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.channel.ChannelHandler;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelInboundHandlerAdapter;
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter;
-
-@ChannelHandler.Sharable
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class IncomingBandwidthDecoder extends ChannelInboundHandlerAdapter {
-  public static final IncomingBandwidthDecoder INSTANCE = new IncomingBandwidthDecoder();
-
-  @Override
-  public void channelRead(final @NotNull ChannelHandlerContext ctx,
-                          final @NotNull Object msg) throws Exception {
-    if (msg instanceof ByteBuf) {
-      TrafficCounter.INCOMING.increment(((ByteBuf) msg).readableBytes());
-    }
-    ctx.fireChannelRead(msg);
-  }
-}

sonar-common/src/main/java/xyz/jonesdev/sonar/common/fallback/traffic/TrafficChannelHooker.java

@@ -1,37 +0,0 @@
-/*
- * 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.traffic;
-
-import io.netty.channel.ChannelPipeline;
-import lombok.experimental.UtilityClass;
-import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.fallback.FallbackPipelines;
-
-@UtilityClass
-public class TrafficChannelHooker implements FallbackPipelines {
-  public void hook(final @NotNull ChannelPipeline pipeline,
-                   final @NotNull String decoder,
-                   final @NotNull String encoder) {
-    if (pipeline.get(FALLBACK_IN_TRAFFIC) == null && pipeline.get(decoder) != null) {
-      pipeline.addBefore(decoder, FALLBACK_IN_TRAFFIC, IncomingBandwidthDecoder.INSTANCE);
-    }
-    if (pipeline.get(FALLBACK_OUT_TRAFFIC) == null && pipeline.get(encoder) != null) {
-      pipeline.addBefore(encoder, FALLBACK_OUT_TRAFFIC, OutgoingBandwidthEncoder.INSTANCE);
-    }
-  }
-}

sonar-common/src/main/java/xyz/jonesdev/sonar/common/statistics/CachedBandwidthStatistics.java

@@ -15,17 +15,17 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.fallback.traffic;
+package xyz.jonesdev.sonar.common.statistics;
 
 import lombok.Getter;
 import lombok.Setter;
-import xyz.jonesdev.sonar.api.profiler.JVMProfiler;
+import xyz.jonesdev.sonar.api.jvm.JVMProcessInformation;
 
 /**
  * This counts all incoming and outgoing traffic.
  */
 @Getter
-public enum TrafficCounter implements JVMProfiler {
+public enum CachedBandwidthStatistics {
   INCOMING,
   OUTGOING;
 
@@ -48,15 +48,15 @@ public enum TrafficCounter implements JVMProfiler {
    * This method is called every second.
    */
   public static synchronized void reset() {
-    for (final TrafficCounter value : values()) {
+    for (final CachedBandwidthStatistics value : values()) {
       value.cacheAndReset();
     }
   }
 
   private void cacheAndReset() {
     ttl += curr; // increment total
-    cachedSecond = formatMemory(curr);
-    cachedTtl = formatMemory(ttl);
+    cachedSecond = JVMProcessInformation.formatMemory(curr);
+    cachedTtl = JVMProcessInformation.formatMemory(ttl);
     curr = 0L; // reset current
   }
 }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/statistics/GlobalSonarStatistics.java

@@ -0,0 +1,162 @@
+/*
+ * 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.statistics;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import org.jetbrains.annotations.ApiStatus;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.statistics.SonarStatistics;
+
+import java.time.Duration;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public final class GlobalSonarStatistics implements SonarStatistics {
+  private static final Cache<Integer, Byte> LOGINS_PER_SECOND = Caffeine.newBuilder()
+    .expireAfterWrite(Duration.ofSeconds(1))
+    .build();
+
+  private static final Cache<Integer, Byte> CONNECTIONS_PER_SECOND = Caffeine.newBuilder()
+    .expireAfterWrite(Duration.ofSeconds(1))
+    .build();
+
+  private static final AtomicInteger ACTION_COUNTER = new AtomicInteger(Integer.MIN_VALUE);
+
+  /**
+   * Helper methods that make it easier to count new statistics
+   */
+
+  @ApiStatus.Internal
+  public static void countConnection() {
+    CONNECTIONS_PER_SECOND.put(ACTION_COUNTER.getAndIncrement(), (byte) 0);
+  }
+
+  @ApiStatus.Internal
+  public static void countLogin() {
+    LOGINS_PER_SECOND.put(ACTION_COUNTER.getAndIncrement(), (byte) 0);
+    totalJoinedPlayers++;
+  }
+
+  // Cache all per-session statistics
+  private static int totalJoinedPlayers;
+  public static int totalSuccessfulVerifications;
+  public static int totalFailedVerifications;
+  public static int totalAttemptedVerifications;
+  public static long totalBlacklistedPlayers;
+
+  /**
+   * Called every time the action bar updates to ensure fresh values
+   */
+  @Override
+  public synchronized void cleanUpCache() {
+    LOGINS_PER_SECOND.cleanUp();
+    CONNECTIONS_PER_SECOND.cleanUp();
+    // Also clean up the blacklist
+    Sonar.get().getFallback().getBlacklist().cleanUp();
+  }
+
+  @Override
+  public long getConnectionsPerSecond() {
+    return CONNECTIONS_PER_SECOND.estimatedSize();
+  }
+
+  @Override
+  public long getLoginsPerSecond() {
+    return LOGINS_PER_SECOND.estimatedSize();
+  }
+
+  @Override
+  public long getCurrentIncomingBandwidth() {
+    return CachedBandwidthStatistics.INCOMING.getCurr();
+  }
+
+  @Override
+  public long getCurrentOutgoingBandwidth() {
+    return CachedBandwidthStatistics.OUTGOING.getCurr();
+  }
+
+  @Override
+  public long getTotalIncomingBandwidth() {
+    return CachedBandwidthStatistics.INCOMING.getTtl();
+  }
+
+  @Override
+  public long getTotalOutgoingBandwidth() {
+    return CachedBandwidthStatistics.OUTGOING.getTtl();
+  }
+
+  @Override
+  public String getCurrentIncomingBandwidthFormatted() {
+    return CachedBandwidthStatistics.INCOMING.getCachedSecond();
+  }
+
+  @Override
+  public String getCurrentOutgoingBandwidthFormatted() {
+    return CachedBandwidthStatistics.OUTGOING.getCachedSecond();
+  }
+
+  @Override
+  public String getTotalIncomingBandwidthFormatted() {
+    return CachedBandwidthStatistics.INCOMING.getCachedTtl();
+  }
+
+  @Override
+  public String getTotalOutgoingBandwidthFormatted() {
+    return CachedBandwidthStatistics.OUTGOING.getCachedTtl();
+  }
+
+  @Override
+  public int getTotalPlayersJoined() {
+    return totalJoinedPlayers;
+  }
+
+  @Override
+  public int getTotalPlayersVerified() {
+    return Sonar.get().getVerifiedPlayerController().estimatedSize();
+  }
+
+  @Override
+  public int getTotalSuccessfulVerifications() {
+    return totalSuccessfulVerifications;
+  }
+
+  @Override
+  public int getTotalFailedVerifications() {
+    return totalFailedVerifications;
+  }
+
+  @Override
+  public long getCurrentAttemptedVerifications() {
+    return Sonar.get().getFallback().getConnected().size();
+  }
+
+  @Override
+  public int getTotalAttemptedVerifications() {
+    return totalAttemptedVerifications;
+  }
+
+  @Override
+  public long getCurrentBlacklistSize() {
+    return Sonar.get().getFallback().getBlacklist().estimatedSize();
+  }
+
+  @Override
+  public long getTotalBlacklistSize() {
+    return totalBlacklistedPlayers;
+  }
+}

sonar-common/src/main/java/xyz/jonesdev/sonar/common/subcommand/impl/BlacklistCommand.java

@@ -54,7 +54,7 @@ public final class BlacklistCommand extends Subcommand {
         if (inetAddress == null) return;
 
         // Make sure the IP is not blacklisted already
-        if (SONAR.getFallback().getBlacklisted().has(inetAddress)) {
+        if (SONAR.getFallback().getBlacklist().asMap().containsKey(inetAddress)) {
           invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getBlacklistDuplicate());
           return;
         }
@@ -66,7 +66,7 @@ public final class BlacklistCommand extends Subcommand {
         }
 
         // Blacklist the given IP address
-        SONAR.getFallback().getBlacklisted().put(inetAddress);
+        SONAR.getFallback().getBlacklist().put(inetAddress, (byte) 0);
         invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getBlacklistAdd()
           .replace("%ip%", rawInetAddress));
         break;
@@ -85,20 +85,20 @@ public final class BlacklistCommand extends Subcommand {
         if (inetAddress == null) return;
 
         // Make sure the IP is blacklisted
-        if (!SONAR.getFallback().getBlacklisted().has(inetAddress)) {
+        if (!SONAR.getFallback().getBlacklist().asMap().containsKey(inetAddress)) {
           invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getBlacklistNotFound());
           return;
         }
 
         // Invalidate the cache entry of the blacklisted IP address
-        SONAR.getFallback().getBlacklisted().invalidate(inetAddress);
+        SONAR.getFallback().getBlacklist().invalidate(inetAddress);
         invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getBlacklistRemove()
           .replace("%ip%", rawInetAddress));
         break;
       }
 
       case "clear": {
-        final int blacklisted = SONAR.getFallback().getBlacklisted().estimatedSize();
+        final long blacklisted = SONAR.getFallback().getBlacklist().estimatedSize();
 
         if (blacklisted == 0) {
           invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getBlacklistEmpty());
@@ -106,7 +106,7 @@ public final class BlacklistCommand extends Subcommand {
         }
 
         // Invalidate all cache entries
-        SONAR.getFallback().getBlacklisted().invalidateAll();
+        SONAR.getFallback().getBlacklist().invalidateAll();
         invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getBlacklistCleared()
           .replace("%removed%", Sonar.DECIMAL_FORMAT.format(blacklisted)));
         break;
@@ -114,7 +114,7 @@ public final class BlacklistCommand extends Subcommand {
 
       case "size": {
         invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getBlacklistSize()
-          .replace("%amount%", Sonar.DECIMAL_FORMAT.format(SONAR.getFallback().getBlacklisted().estimatedSize())));
+          .replace("%amount%", Sonar.DECIMAL_FORMAT.format(SONAR.getFallback().getBlacklist().estimatedSize())));
         break;
       }
 

sonar-common/src/main/java/xyz/jonesdev/sonar/common/subcommand/impl/DumpCommand.java

@@ -17,21 +17,25 @@
 
 package xyz.jonesdev.sonar.common.subcommand.impl;
 
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
 import lombok.RequiredArgsConstructor;
 import lombok.val;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Unmodifiable;
-import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.SonarPlatform;
 import xyz.jonesdev.sonar.api.command.CommandInvocation;
 import xyz.jonesdev.sonar.api.command.subcommand.Subcommand;
 import xyz.jonesdev.sonar.api.command.subcommand.SubcommandInfo;
-import xyz.jonesdev.sonar.api.profiler.JVMProfiler;
 
+import java.lang.management.ManagementFactory;
+import java.lang.management.RuntimeMXBean;
 import java.util.List;
 import java.util.Map;
 import java.util.WeakHashMap;
 
+import static xyz.jonesdev.sonar.api.jvm.JVMProcessInformation.*;
+
 // This command is only used to display helpful information to help
 // the Sonar contributors to fix issues more quickly
 @SubcommandInfo(
@@ -39,11 +43,14 @@ import java.util.WeakHashMap;
   description = "Print developer information",
   onlyConsole = true
 )
-public final class DumpCommand extends Subcommand implements JVMProfiler {
+public final class DumpCommand extends Subcommand {
+
+  private static final RuntimeMXBean RUNTIME_MX_BEAN = ManagementFactory.getRuntimeMXBean();
+  private static final Gson GSON = new GsonBuilder().create();
 
   @Override
   protected void execute(final @NotNull CommandInvocation invocation) {
-    final String json = Sonar.GENERAL_GSON.toJson(collectMappedInformation());
+    final String json = GSON.toJson(collectMappedInformation());
     SONAR.getLogger().info("Generated dump: {}", json);
   }
 

sonar-common/src/main/java/xyz/jonesdev/sonar/common/subcommand/impl/NotifyCommand.java

@@ -31,13 +31,13 @@ public final class NotifyCommand extends Subcommand {
 
   @Override
   protected void execute(final @NotNull CommandInvocation invocation) {
-    if (SONAR.getNotificationHandler().isSubscribed(invocation.getSender().getName())) {
-      SONAR.getNotificationHandler().unsubscribe(invocation.getSender().getName());
+    if (SONAR.getNotificationHandler().isSubscribed(invocation.getSender().getUuid())) {
+      SONAR.getNotificationHandler().unsubscribe(invocation.getSender().getUuid());
       invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getNotificationsUnsubscribed());
       return;
     }
 
     invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getNotificationsSubscribed());
-    SONAR.getNotificationHandler().subscribe(invocation.getSender().getName());
+    SONAR.getNotificationHandler().subscribe(invocation.getSender().getUuid());
   }
 }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/subcommand/impl/StatisticsCommand.java

@@ -23,11 +23,10 @@ import xyz.jonesdev.sonar.api.command.CommandInvocation;
 import xyz.jonesdev.sonar.api.command.subcommand.Subcommand;
 import xyz.jonesdev.sonar.api.command.subcommand.SubcommandInfo;
 import xyz.jonesdev.sonar.api.command.subcommand.argument.Argument;
-import xyz.jonesdev.sonar.api.fallback.traffic.TrafficCounter;
-import xyz.jonesdev.sonar.api.profiler.JVMProfiler;
-import xyz.jonesdev.sonar.api.statistics.Statistics;
+import xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics;
 
 import static xyz.jonesdev.sonar.api.Sonar.DECIMAL_FORMAT;
+import static xyz.jonesdev.sonar.api.jvm.JVMProcessInformation.*;
 
 @SubcommandInfo(
   name = "statistics",
@@ -40,7 +39,7 @@ import static xyz.jonesdev.sonar.api.Sonar.DECIMAL_FORMAT;
   },
   argumentsRequired = false
 )
-public final class StatisticsCommand extends Subcommand implements JVMProfiler {
+public final class StatisticsCommand extends Subcommand {
   private enum StatisticType {
     GENERAL,
     NETWORK,
@@ -74,12 +73,12 @@ public final class StatisticsCommand extends Subcommand implements JVMProfiler {
         invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getGeneralStatistics()
           .replace("%verified%", DECIMAL_FORMAT.format(SONAR.getVerifiedPlayerController().estimatedSize()))
           .replace("%verifying%", DECIMAL_FORMAT.format(SONAR.getFallback().getConnected().size()))
-          .replace("%blacklisted%", DECIMAL_FORMAT.format(SONAR.getFallback().getBlacklisted().estimatedSize()))
+          .replace("%blacklisted%", DECIMAL_FORMAT.format(SONAR.getFallback().getBlacklist().estimatedSize()))
           .replace("%queued%", DECIMAL_FORMAT.format(SONAR.getFallback().getQueue().getQueuedPlayers().size()))
           .replace("%uptime%", String.format("%dd %dh %dm %ds", days, hours, minutes, seconds % 60L))
-          .replace("%total_joins%", DECIMAL_FORMAT.format(Statistics.TOTAL_TRAFFIC.get()))
-          .replace("%total_attempts%", DECIMAL_FORMAT.format(Statistics.REAL_TRAFFIC.get()))
-          .replace("%total_failed%", DECIMAL_FORMAT.format(Statistics.FAILED_VERIFICATIONS.get())));
+          .replace("%total_joins%", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalPlayersJoined()))
+          .replace("%total_attempts%", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalAttemptedVerifications()))
+          .replace("%total_failed%", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalFailedVerifications())));
         break;
       }
 
@@ -105,10 +104,10 @@ public final class StatisticsCommand extends Subcommand implements JVMProfiler {
 
       case NETWORK: {
         invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getNetworkStatistics()
-          .replace("%incoming%", TrafficCounter.INCOMING.getCachedSecond())
-          .replace("%outgoing%", TrafficCounter.OUTGOING.getCachedSecond())
-          .replace("%ttl_incoming%", TrafficCounter.INCOMING.getCachedTtl())
-          .replace("%ttl_outgoing%", TrafficCounter.OUTGOING.getCachedTtl()));
+          .replace("%incoming%", CachedBandwidthStatistics.INCOMING.getCachedSecond())
+          .replace("%outgoing%", CachedBandwidthStatistics.OUTGOING.getCachedSecond())
+          .replace("%ttl_incoming%", CachedBandwidthStatistics.INCOMING.getCachedTtl())
+          .replace("%ttl_outgoing%", CachedBandwidthStatistics.OUTGOING.getCachedTtl()));
         break;
       }
     }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/subcommand/impl/VerboseCommand.java

@@ -32,8 +32,8 @@ public final class VerboseCommand extends Subcommand {
 
   @Override
   protected void execute(final @NotNull CommandInvocation invocation) {
-    if (SONAR.getVerboseHandler().isSubscribed(invocation.getSender().getName())) {
-      SONAR.getVerboseHandler().unsubscribe(invocation.getSender().getName());
+    if (SONAR.getVerboseHandler().isSubscribed(invocation.getSender().getUuid())) {
+      SONAR.getVerboseHandler().unsubscribe(invocation.getSender().getUuid());
       invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getVerboseUnsubscribed());
       // Reset ActionBar component when unsubscribing
       invocation.getSender().getAudience().sendActionBar(Component.empty());
@@ -41,6 +41,6 @@ public final class VerboseCommand extends Subcommand {
     }
 
     invocation.getSender().sendMessage(SONAR.getConfig().getCommands().getVerboseSubscribed());
-    SONAR.getVerboseHandler().subscribe(invocation.getSender().getName());
+    SONAR.getVerboseHandler().subscribe(invocation.getSender().getUuid());
   }
 }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/utility/component/ComponentHolder.java

@@ -17,23 +17,34 @@
 
 package xyz.jonesdev.sonar.common.utility.component;
 
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonPrimitive;
+import com.google.gson.*;
 import com.google.gson.internal.LazilyParsedNumber;
-import lombok.experimental.UtilityClass;
+import io.netty.buffer.ByteBuf;
 import net.kyori.adventure.nbt.*;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 
-// Taken from
+import static xyz.jonesdev.sonar.common.utility.protocol.ProtocolUtil.writeNamelessCompoundTag;
+import static xyz.jonesdev.sonar.common.utility.protocol.ProtocolUtil.writeString;
+
+// Mostly taken from
 // https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/packet/chat/ComponentHolder.java
-@UtilityClass
-public class ComponentSerializer {
-  public static BinaryTag serialize(final JsonElement json) {
+public final class ComponentHolder {
+  private final String serializedComponent;
+  private BinaryTag cachedBinaryTag;
+
+  public ComponentHolder(final Component component) {
+    this.serializedComponent = GsonComponentSerializer.gson().serialize(component);
+  }
+
+  private BinaryTag serialize(final JsonElement json) {
     if (json instanceof JsonPrimitive) {
       final JsonPrimitive jsonPrimitive = (JsonPrimitive) json;
 
@@ -65,13 +76,13 @@ public class ComponentSerializer {
     } else if (json instanceof JsonObject) {
       final CompoundBinaryTag.Builder compound = CompoundBinaryTag.builder();
 
-      for (Map.Entry<String, JsonElement> property : ((JsonObject) json).entrySet()) {
+      for (final Map.Entry<String, JsonElement> property : ((JsonObject) json).entrySet()) {
         compound.put(property.getKey(), serialize(property.getValue()));
       }
 
       return compound.build();
     } else if (json instanceof JsonArray) {
-      final JsonArray jsonArray = (JsonArray) json;
+      final JsonArray jsonArray = json.getAsJsonArray();
 
       if (jsonArray.size() == 0) {
         return ListBinaryTag.empty();
@@ -91,7 +102,7 @@ public class ComponentSerializer {
         }
       }
 
-      switch (listType.id()) {
+      switch (Objects.requireNonNull(listType).id()) {
         case 1://BinaryTagTypes.BYTE:
           final byte[] bytes = new byte[jsonArray.size()];
           for (int i = 0; i < bytes.length; i++) {
@@ -123,8 +134,22 @@ public class ComponentSerializer {
           });
           break;
       }
+
       return ListBinaryTag.listBinaryTag(listType, tagItems);
     }
+
     return EndBinaryTag.endBinaryTag();
   }
+
+  public void write(final @NotNull ByteBuf byteBuf,
+                    final @NotNull ProtocolVersion protocolVersion) {
+    if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_20_3) >= 0) {
+      if (cachedBinaryTag == null) {
+        cachedBinaryTag = serialize(new JsonParser().parse(serializedComponent));
+      }
+      writeNamelessCompoundTag(byteBuf, cachedBinaryTag);
+    } else {
+      writeString(byteBuf, serializedComponent);
+    }
+  }
 }

sonar-common/src/main/java/xyz/jonesdev/sonar/common/utility/geyser/GeyserUtil.java

@@ -18,6 +18,7 @@
 package xyz.jonesdev.sonar.common.utility.geyser;
 
 import io.netty.channel.Channel;
+import io.netty.util.AttributeKey;
 import lombok.experimental.UtilityClass;
 import org.jetbrains.annotations.NotNull;
 
@@ -28,17 +29,16 @@ import java.net.InetSocketAddress;
  */
 @UtilityClass
 public class GeyserUtil {
+  // https://github.com/GeyserMC/Floodgate/blob/master/core/src/main/java/org/geysermc/floodgate/module/CommonModule.java#L206
+  private final AttributeKey<Object> PLAYER_ATTRIBUTE = AttributeKey.valueOf("floodgate-player");
 
   /**
    * @param channel Channel of the player
    * @return Whether the player is on GeyserMC or not
    */
-  public boolean isGeyserConnection(final @NotNull Channel channel) {
-    // https://discord.com/channels/613163671870242838/613170125696270357/1168599123889504266
-    // Every floodgate player has a channel attribute called "floodgate-player"
-    // However, this is not safe to use as even Java players sometimes have this attribute.
-    // Instead, we should check if the port is 0, since TCP didn't resolve a port (UDP)
-    // Thanks to @dbruni on Discord who reported it in ticket-0072
-    return ((InetSocketAddress) channel.remoteAddress()).getPort() == 0;
+  public boolean isGeyserConnection(final @NotNull Channel channel,
+                                    final @NotNull InetSocketAddress originalAddress) {
+    return originalAddress.getPort() == 0 // check for floodgate on the server
+      || channel.attr(PLAYER_ATTRIBUTE).get() != null; // check for standalone Geyser proxy connection
   }
 }