Release 2.1.9 (#389)

Bumps [com.gradleup.shadow](https://github.com/GradleUp/shadow) from 8.3.1 to 8.3.2.
- [Release notes](https://github.com/GradleUp/shadow/releases)
- [Commits](https://github.com/GradleUp/shadow/compare/8.3.1...8.3.2)

---
updated-dependencies:
- dependency-name: com.gradleup.shadow
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.editorconfig

@@ -7,7 +7,7 @@ indent_size = 2
 insert_final_newline = true
 trim_trailing_whitespace = true
 
-[{*.java,*.kt}]
+[*.java]
 ij_java_wrap_long_lines = true
 
 [{*.md,*.yml}]

.github/workflows/gradle.yml

@@ -9,9 +9,9 @@ name: Sonar CI
 
 on:
   push:
-    branches: [ "main", "dev" ]
+    branches: [ "main" ]
   pull_request:
-    branches: [ "main", "dev" ]
+    branches: [ "main" ]
 
 permissions:
   contents: read
@@ -22,12 +22,41 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
+
     - name: Set up JDK 17
       uses: actions/setup-java@v3
       with:
         java-version: '17'
         distribution: 'temurin'
+
     - name: Build with Gradle
-      uses: gradle/gradle-build-action@bd5760595778326ba7f1441bcf7e88b49de61a25 # v2.6.0
+      uses: gradle/gradle-build-action@v3
       with:
         arguments: build-sonar
+
+    - name: Upload Bukkit Artifact
+      uses: actions/upload-artifact@v3.1.3
+      with:
+        # Artifact name
+        name: Sonar
+        # A file, directory or wildcard pattern that describes what to upload
+        path: bukkit/build/libs/Sonar-Bukkit.jar
+        if-no-files-found: error
+
+    - name: Upload BungeeCord Artifact
+      uses: actions/upload-artifact@v3.1.3
+      with:
+        # Artifact name
+        name: Sonar
+        # A file, directory or wildcard pattern that describes what to upload
+        path: bungeecord/build/libs/Sonar-Bungee.jar
+        if-no-files-found: error
+
+    - name: Upload Velocity Artifact
+      uses: actions/upload-artifact@v3.1.3
+      with:
+        # Artifact name
+        name: Sonar
+        # A file, directory or wildcard pattern that describes what to upload
+        path: velocity/build/libs/Sonar-Velocity.jar
+        if-no-files-found: error

api/build.gradle.kts

@@ -9,5 +9,11 @@ dependencies {
   compileOnly(rootProject.libs.annotations)
 }
 
+tasks {
+  shadowJar {
+    archiveFileName = "sonar-api-${rootProject.version}.jar"
+  }
+}
+
 java.sourceCompatibility = JavaVersion.VERSION_11
 java.targetCompatibility = JavaVersion.VERSION_11

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

@@ -97,6 +97,6 @@ public interface Sonar {
 
   @NotNull
   static Sonar get() {
-    return SonarSupplier.get();
+    return SonarSupplier.sonar;
   }
 }

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

@@ -19,20 +19,15 @@ package xyz.jonesdev.sonar.api;
 
 import lombok.experimental.UtilityClass;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.exception.AlreadyInitializedException;
 
 @UtilityClass
 public class SonarSupplier {
-  private Sonar _sonar;
+  Sonar sonar;
 
-  public void set(final @NotNull Sonar instance) {
-    if (_sonar != null) {
-      throw new AlreadyInitializedException("Sonar is already initialized");
+  public void set(final @NotNull Sonar _sonar) {
+    if (sonar != null) {
+      throw new IllegalStateException("Sonar is already initialized");
     }
-    _sonar = instance;
-  }
-
-  public @NotNull Sonar get() {
-    return _sonar;
+    sonar = _sonar;
   }
 }

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

@@ -26,6 +26,7 @@ import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.command.subcommand.Subcommand;
+import xyz.jonesdev.sonar.api.update.UpdateChecker;
 
 import java.util.*;
 
@@ -66,11 +67,18 @@ public interface SonarCommand {
       // Invoke subcommand
       command.invoke(source, args);
     }, () -> {
+      final UpdateChecker.CheckResult checkResult = UpdateChecker.getLastCheckResult();
+      Component version = Component.text(Sonar.get().getVersion().getFormatted());
+      if (checkResult.getConfigKey() != null) {
+        version = version.append(MiniMessage.miniMessage().deserialize(
+          Sonar.get().getConfig().getMessagesConfig().getString("commands.main." + checkResult.getConfigKey())));
+      }
+
       // Print standard help message
       source.sendMessage(MiniMessage.miniMessage().deserialize(
         String.join("<newline>",
           Sonar.get().getConfig().getMessagesConfig().getStringList("commands.main.header")),
-        Placeholder.unparsed("version", Sonar.get().getVersion().getFormatted()),
+        Placeholder.component("version", version),
         Placeholder.unparsed("platform", Sonar.get().getPlatform().getDisplayName()),
         Placeholder.unparsed("copyright-year", String.valueOf(Calendar.getInstance().get(Calendar.YEAR)))));
 
@@ -94,7 +102,7 @@ public interface SonarCommand {
     });
   }
 
-  static void prepareCachedMessages() {
+  static void prepareCachedTabSuggestions() {
     // Don't re-cache tab suggestions
     if (!TAB_SUGGESTIONS.isEmpty()) return;
     // Cache tab suggestions

api/src/main/java/xyz/jonesdev/sonar/api/config/SonarConfiguration.java

@@ -183,10 +183,11 @@ public final class SonarConfiguration {
 
     final String backgroundPath = generalConfig.getString("verification.checks.map-captcha.background");
     if (!backgroundPath.isEmpty()) {
-      try (final InputStream inputStream = new FileInputStream(backgroundPath)) {
-        verification.map.backgroundImage = inputStream;
-      } catch (IOException exception) {
-        Sonar.get().getLogger().error("Could not find background image", exception);
+      final File backgroundFile = new File(pluginFolder, backgroundPath);
+      if (backgroundFile.exists()) {
+        verification.map.backgroundImage = backgroundFile;
+      } else {
+        Sonar.get().getLogger().error("Could not find background image {}", backgroundFile.getAbsolutePath());
       }
     }
 
@@ -197,7 +198,6 @@ public final class SonarConfiguration {
     verification.gamemode = Verification.Gamemode.valueOf(generalConfig.getString("verification.gamemode"));
     verification.validNameRegex = Pattern.compile(generalConfig.getString("verification.checks.valid-name-regex"));
     verification.validLocaleRegex = Pattern.compile(generalConfig.getString("verification.checks.valid-locale-regex"));
-    verification.maxLoginPackets = clamp(generalConfig.getInt("verification.checks.max-login-packets"), 128, 8192);
 
     verification.checkGeyser = generalConfig.getBoolean("verification.check-geyser-players");
     verification.logConnections = generalConfig.getBoolean("verification.log-connections");
@@ -245,7 +245,7 @@ public final class SonarConfiguration {
     noPermission = MiniMessage.miniMessage().deserialize(messagesConfig.getString("commands.no-permission"),
       Placeholder.component("prefix", prefix));
 
-    SonarCommand.prepareCachedMessages();
+    SonarCommand.prepareCachedTabSuggestions();
 
     supportUrl = messagesConfig.getString("support-url");
     header = MiniMessage.miniMessage().deserialize(
@@ -367,7 +367,7 @@ public final class SonarConfiguration {
       private int maxDuration;
       private int maxTries;
       private String alphabet;
-      private InputStream backgroundImage;
+      private File backgroundImage;
     }
 
     @Getter
@@ -415,7 +415,6 @@ public final class SonarConfiguration {
     private Pattern validNameRegex;
     private Pattern validLocaleRegex;
 
-    private int maxLoginPackets;
     private int readTimeout;
     private int writeTimeout;
     private int reconnectDelay;

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

@@ -28,7 +28,6 @@ import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.Range;
-import org.jetbrains.annotations.Unmodifiable;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
 import xyz.jonesdev.sonar.api.database.model.VerifiedPlayer;
@@ -38,15 +37,18 @@ import java.sql.SQLException;
 import java.sql.Timestamp;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 public final class VerifiedPlayerController {
   private static final ExecutorService DB_UPDATE_SERVICE = Executors.newSingleThreadExecutor();
 
-  private final Map<String, Collection<UUID>> cache = new ConcurrentHashMap<>(128);
+  @Getter
+  private final Set<String> cache = Collections.synchronizedSet(new HashSet<>());
   private @Nullable ConnectionSource connectionSource;
   private Dao<VerifiedPlayer, Integer> dao;
   private QueryBuilder<VerifiedPlayer, Integer> queryBuilder;
@@ -114,13 +116,13 @@ public final class VerifiedPlayerController {
           // 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);
+          dao.queryForAll().forEach(verifiedPlayer -> cache.add(verifiedPlayer.getFingerprint()));
         } catch (SQLException exception) {
-          Sonar.get().getLogger().error("Error initializing database: {}", exception);
+          exception.printStackTrace(System.err);
         }
       });
     } catch (SQLException exception) {
-      Sonar.get().getLogger().error("Error setting up database: {}", exception);
+      exception.printStackTrace(System.err);
     }
   }
 
@@ -133,7 +135,7 @@ public final class VerifiedPlayerController {
       try {
         connectionSource.close();
       } catch (Exception exception) {
-        Sonar.get().getLogger().error("Error closing database: {}", exception);
+        exception.printStackTrace(System.err);
       }
     }
   }
@@ -163,10 +165,10 @@ public final class VerifiedPlayerController {
    * First, remove the player from the local cache and then,
    * secondly, asynchronously add the player to the database.
    *
-   * @param inetAddress InetAddress of the VerifiedPlayer model
+   * @param fingerprint Fingerprint of the verified player
    */
-  public void remove(final @NotNull String inetAddress) {
-    _remove(inetAddress);
+  public void remove(final @NotNull String fingerprint) {
+    cache.remove(fingerprint);
 
     // Don't try to update the column if the database type is NONE
     if (cachedDatabaseType == SonarConfiguration.Database.Type.NONE) {
@@ -182,7 +184,7 @@ public final class VerifiedPlayerController {
 
       try {
         final List<VerifiedPlayer> verifiedPlayer = queryBuilder.where()
-          .eq("ip_address", inetAddress)
+          .eq("fingerprint", fingerprint)
           .query();
 
         if (verifiedPlayer != null) {
@@ -191,20 +193,11 @@ public final class VerifiedPlayerController {
           }
         }
       } catch (SQLException exception) {
-        Sonar.get().getLogger().error("Error trying to remove entry: {}", exception);
+        exception.printStackTrace(System.err);
       }
     });
   }
 
-  /**
-   * Locally remove the object from the cache
-   *
-   * @param inetAddress IP address of the player
-   */
-  private void _remove(final @NotNull String inetAddress) {
-    cache.remove(inetAddress);
-  }
-
   /**
    * First, cache the player locally and then,
    * secondly, asynchronously add the player to the database.
@@ -212,7 +205,7 @@ public final class VerifiedPlayerController {
    * @param player VerifiedPlayer model
    */
   public void add(final @NotNull VerifiedPlayer player) {
-    _add(player);
+    cache.add(player.getFingerprint());
 
     // Don't try to update the column if the database type is NONE
     if (cachedDatabaseType == SonarConfiguration.Database.Type.NONE) {
@@ -229,21 +222,11 @@ public final class VerifiedPlayerController {
       try {
         dao.createIfNotExists(player);
       } catch (SQLException exception) {
-        Sonar.get().getLogger().error("Error trying to add entry: {}", exception);
+        exception.printStackTrace(System.err);
       }
     });
   }
 
-  /**
-   * Locally cache the object
-   *
-   * @param player VerifiedPlayer model
-   */
-  private void _add(final @NotNull VerifiedPlayer player) {
-    cache.computeIfAbsent(player.getInetAddress(), v -> new ArrayList<>())
-      .add(player.getPlayerUuid());
-  }
-
   /**
    * Returns the number of verified IP addresses
    *
@@ -253,26 +236,6 @@ public final class VerifiedPlayerController {
     return cache.size();
   }
 
-  /**
-   * Returns the sum of verified IP addresses
-   * and their respective collection of UUIDs
-   *
-   * @return Exact size of all total verified players
-   */
-  @Deprecated
-  public synchronized int exactSize() {
-    return cache.values().stream()
-      .mapToInt(Collection::size)
-      .sum();
-  }
-
-  /**
-   * @return {@link java.util.Collection} of UUIDs associated with an IP address
-   */
-  public @Unmodifiable Collection<UUID> getUUIDs(final @NotNull String inetAddress) {
-    return cache.getOrDefault(inetAddress, Collections.emptyList());
-  }
-
   /**
    * Clear the local cache, and, if the database type is set,
    * remove the table from the database.
@@ -285,29 +248,8 @@ public final class VerifiedPlayerController {
       try {
         dao.deleteBuilder().delete();
       } catch (SQLException exception) {
-        Sonar.get().getLogger().error("Error trying to clear entries: {}", exception);
+        exception.printStackTrace(System.err);
       }
     }
   }
-
-  /**
-   * @param inetAddress IP address
-   * @param uuid        UUID associated to the IP
-   * @return Whether the local cache contains the IP and UUID
-   */
-  public boolean has(final @NotNull String inetAddress, final @NotNull UUID uuid) {
-    final Collection<UUID> got = cache.get(inetAddress);
-    if (got != null) {
-      return got.contains(uuid);
-    }
-    return false;
-  }
-
-  /**
-   * @param inetAddress IP address
-   * @return Whether the local cache contains the IP
-   */
-  public boolean has(final @NotNull String inetAddress) {
-    return cache.containsKey(inetAddress);
-  }
 }

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

@@ -25,34 +25,23 @@ import lombok.NoArgsConstructor;
 import lombok.ToString;
 import org.jetbrains.annotations.NotNull;
 
-import java.net.InetAddress;
 import java.sql.Timestamp;
-import java.util.UUID;
 
 @Getter
 @ToString
+@DatabaseTable(tableName = "sonar_fingerprints")
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
-@DatabaseTable(tableName = "sonar_verified_players")
 public final class VerifiedPlayer {
   @SuppressWarnings("unused")
   @DatabaseField(generatedId = true)
   private int id;
 
   @DatabaseField(
-    columnName = "ip_address",
+    columnName = "fingerprint",
     canBeNull = false,
-    uniqueIndexName = "ip_address_player_uuid_idx",
-    width = 16
+    width = 48
   )
-  private String inetAddress;
-
-  @DatabaseField(
-    columnName = "player_uuid",
-    canBeNull = false,
-    uniqueIndexName = "ip_address_player_uuid_idx",
-    width = 36
-  )
-  private UUID playerUuid;
+  private String fingerprint;
 
   @DatabaseField(
     columnName = "timestamp",
@@ -60,17 +49,9 @@ public final class VerifiedPlayer {
   )
   private Timestamp timestamp;
 
-  public VerifiedPlayer(final @NotNull InetAddress inetAddress,
-                        final @NotNull UUID playerUuid,
+  public VerifiedPlayer(final @NotNull String fingerprint,
                         final long timestamp) {
-    this(inetAddress.getHostAddress(), playerUuid, timestamp);
-  }
-
-  public VerifiedPlayer(final @NotNull String inetAddress,
-                        final @NotNull UUID playerUuid,
-                        final long timestamp) {
-    this.inetAddress = inetAddress;
-    this.playerUuid = playerUuid;
+    this.fingerprint = fingerprint;
     this.timestamp = new Timestamp(timestamp);
   }
 }

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

@@ -17,13 +17,13 @@
 
 package xyz.jonesdev.sonar.api.event;
 
+import org.jetbrains.annotations.NotNull;
+
 @FunctionalInterface
 public interface SonarEventListener {
 
   /**
-   * Handles the publishing of an event
-   *
-   * @param event [Cancellable] Sonar event
+   * Handles the publishing of an event through Sonar's API
    */
-  void handle(final SonarEvent event);
+  void handle(final @NotNull SonarEvent event);
 }

api/src/main/java/xyz/jonesdev/sonar/api/event/impl/CaptchaGenerationEndEvent.java

@@ -0,0 +1,32 @@
+/*
+ * 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.event.impl;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+import xyz.jonesdev.sonar.api.event.SonarEvent;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;
+
+@Getter
+@ToString
+@RequiredArgsConstructor
+public final class CaptchaGenerationEndEvent implements SonarEvent {
+  private final SystemTimer timer;
+  private final int amountGenerated;
+}

api/src/main/java/xyz/jonesdev/sonar/api/event/impl/CaptchaGenerationStartEvent.java

@@ -15,16 +15,17 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.exception;
+package xyz.jonesdev.sonar.api.event.impl;
 
-import org.jetbrains.annotations.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+import xyz.jonesdev.sonar.api.event.SonarEvent;
+import xyz.jonesdev.sonar.api.fallback.captcha.CaptchaGenerator;
 
-public final class AlreadyInitializedException extends RuntimeException {
-  public AlreadyInitializedException(final @NotNull String message) {
-    super(message);
-  }
-
-  public Throwable fillInStackTrace() {
-    return this;
-  }
+@Getter
+@Setter
+@AllArgsConstructor
+public final class CaptchaGenerationStartEvent implements SonarEvent {
+  private CaptchaGenerator captchaGenerator;
 }

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

@@ -22,15 +22,12 @@ import lombok.RequiredArgsConstructor;
 import lombok.ToString;
 import xyz.jonesdev.sonar.api.event.SonarEvent;
 import xyz.jonesdev.sonar.api.fallback.FallbackUser;
-
-import java.util.UUID;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;
 
 @Getter
 @ToString
 @RequiredArgsConstructor
 public final class UserVerifySuccessEvent implements SonarEvent {
-  private final String username;
-  private final UUID offlineUuid;
   private final FallbackUser user;
-  private final long timeTakenToVerify;
+  private final SystemTimer loginTimer;
 }

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

@@ -22,7 +22,6 @@ import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
-import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
 import xyz.jonesdev.sonar.api.fallback.captcha.CaptchaGenerator;
@@ -37,19 +36,15 @@ import java.util.concurrent.ConcurrentMap;
 public final class Fallback {
   public static final Fallback INSTANCE = new Fallback();
 
-  // Map of all players connected to the server in general
   private final ConcurrentMap<InetAddress, Integer> online = new ConcurrentHashMap<>(128);
-  // Map of all connected IP addresses (used for fast checking)
-  private final ConcurrentMap<InetAddress, Byte> connected = new ConcurrentHashMap<>(128);
-  // Cache of all blacklisted IP addresses to ensure each entry can expire after the given time
+  private final ConcurrentMap<InetAddress, Boolean> connected = new ConcurrentHashMap<>(256);
+  private final FallbackLoginQueue queue = new FallbackLoginQueue();
   @Setter
   private Cache<String, Integer> blacklist;
   @Setter
   private long blacklistTime;
   @Setter
   private CaptchaGenerator captchaGenerator;
-
-  private final @NotNull FallbackQueue queue = new FallbackQueue();
   @Setter
   private Ratelimiter<InetAddress> ratelimiter;
 

api/src/main/java/xyz/jonesdev/sonar/api/fallback/FallbackLoginQueue.java

@@ -23,8 +23,6 @@ import lombok.RequiredArgsConstructor;
 import xyz.jonesdev.sonar.api.Sonar;
 
 import java.net.InetAddress;
-import java.util.Iterator;
-import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ExecutorService;
@@ -32,27 +30,24 @@ import java.util.concurrent.Executors;
 
 @Getter
 @RequiredArgsConstructor(access = AccessLevel.PROTECTED)
-public final class FallbackQueue {
+public final class FallbackLoginQueue {
   // Fixed thread pool executor for all new verifications
   private static final int THREAD_POOL_SIZE = Math.min(0x7fff, Runtime.getRuntime().availableProcessors() * 2);
   private static final ExecutorService QUEUE_EXECUTOR = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
 
-  private final ConcurrentMap<InetAddress, Runnable> players = new ConcurrentHashMap<>(
-    128, 0.75f, Runtime.getRuntime().availableProcessors());
+  private final ConcurrentMap<InetAddress, Runnable> players = new ConcurrentHashMap<>(512);
 
   public void poll() {
-    final int maxQueuePolls = Sonar.get().getConfig().getQueue().getMaxQueuePolls();
-    int index = 0;
-
-    // Iterate through the map and process up to maxQueuePolls entries
+    final int maxQueuePolls = Math.min(players.size(), Sonar.get().getConfig().getQueue().getMaxQueuePolls());
+    // No need to initiate an executor service task if nobody is currently queued
+    if (maxQueuePolls <= 0) return;
     // We need to be cautious here since we don't want any concurrency issues
-    final Iterator<Map.Entry<InetAddress, Runnable>> iterator = players.entrySet().iterator();
-    while (iterator.hasNext() && index++ < maxQueuePolls) {
-      // Run the cached runnable
-      final Map.Entry<InetAddress, Runnable> entry = iterator.next();
-      QUEUE_EXECUTOR.execute(entry.getValue());
-      // Remove runnable from the map
-      iterator.remove();
-    }
+    QUEUE_EXECUTOR.execute(() -> {
+      final var iterator = players.entrySet().iterator();
+      for (int index = 0; index < maxQueuePolls && iterator.hasNext(); index++) {
+        iterator.next().getValue().run();
+        iterator.remove();
+      }
+    });
   }
 }

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

@@ -18,7 +18,6 @@
 package xyz.jonesdev.sonar.api.fallback;
 
 import io.netty.channel.Channel;
-import io.netty.channel.ChannelPipeline;
 import io.netty.util.ReferenceCountUtil;
 import net.kyori.adventure.text.Component;
 import org.jetbrains.annotations.NotNull;
@@ -26,14 +25,10 @@ import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
 
 import java.net.InetAddress;
-import java.util.UUID;
 
 public interface FallbackUser {
   @NotNull
-  Channel getChannel();
-
-  @NotNull
-  ChannelPipeline getPipeline();
+  Channel channel();
 
   @NotNull
   InetAddress getInetAddress();
@@ -45,15 +40,14 @@ public interface FallbackUser {
   SystemTimer getLoginTimer();
 
   @NotNull
-  UUID getOfflineUuid();
+  String getFingerprint();
 
-  boolean isReceivedClientSettings();
+  @NotNull
+  String getUsername();
 
-  void setReceivedClientSettings(final boolean receivedClientSettings);
+  boolean isForceCaptcha();
 
-  boolean isReceivedPluginMessage();
-
-  void setReceivedPluginMessage(final boolean receivedPluginMessage);
+  void setForceCaptcha(final boolean isForceCaptcha);
 
   boolean isGeyser();
 
@@ -65,22 +59,14 @@ public interface FallbackUser {
    */
   void disconnect(final @NotNull Component reason);
 
-  /**
-   * Takes over the channel and begins the verification process
-   *
-   * @param username    Username of the player
-   * @param offlineUuid UUID of the player
-   */
-  void hijack(final @NotNull String username, final @NotNull UUID offlineUuid);
-
   /**
    * Sends a packet/message to the player
    *
    * @param msg Message to send to the player
    */
   default void write(final @NotNull Object msg) {
-    if (getChannel().isActive()) {
-      getChannel().writeAndFlush(msg, getChannel().voidPromise());
+    if (channel().isActive()) {
+      channel().writeAndFlush(msg, channel().voidPromise());
     } else {
       ReferenceCountUtil.release(msg);
     }
@@ -91,22 +77,10 @@ public interface FallbackUser {
    * sent once all messages are flushed.
    */
   default void delayedWrite(final @NotNull Object msg) {
-    if (getChannel().isActive()) {
-      getChannel().write(msg, getChannel().voidPromise());
+    if (channel().isActive()) {
+      channel().write(msg, channel().voidPromise());
     } else {
       ReferenceCountUtil.release(msg);
     }
   }
-
-  /**
-   * Disconnects the player who failed the verification
-   * and caches them in FAILED_VERIFICATIONS.
-   * If the player fails the verification twice,
-   * the player will be temporarily denied from verifying.
-   *
-   * @param reason Reason for failing the verification
-   * @apiNote The {@link xyz.jonesdev.sonar.api.event.impl.UserVerifyFailedEvent}
-   * will not be thrown if no reason is given
-   */
-  void fail(final @NotNull String reason);
 }

api/src/main/java/xyz/jonesdev/sonar/api/fallback/captcha/CaptchaGenerator.java

@@ -17,9 +17,15 @@
 
 package xyz.jonesdev.sonar.api.fallback.captcha;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.awt.image.BufferedImage;
 
 @FunctionalInterface
 public interface CaptchaGenerator {
-  BufferedImage createImage(final char[] answer);
+
+  /**
+   * Generates a {@link java.awt.image.BufferedImage} that shows the answer to the CAPTCHA
+   */
+  @NotNull BufferedImage createImage(final char @NotNull [] answer);
 }

api/src/main/java/xyz/jonesdev/sonar/api/fingerprint/FingerprintingUtil.java

@@ -0,0 +1,38 @@
+/*
+ * 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.fingerprint;
+
+import lombok.experimental.UtilityClass;
+import org.jetbrains.annotations.NotNull;
+
+@UtilityClass
+public class FingerprintingUtil {
+
+  /**
+   * Returns a hex string representing a hash of the username and IP address
+   */
+  public @NotNull String getFingerprint(final @NotNull String username,
+                                        final @NotNull String hostAddress) {
+    final int hash0 = username.hashCode();
+    final int hash1 = hostAddress.hashCode();
+    final int combined = hash0 + hash1;
+    return Integer.toHexString(hash0 >> 4)
+      + Integer.toHexString(combined << 2)
+      + Integer.toHexString(hash1 >> 4);
+  }
+}

api/src/main/java/xyz/jonesdev/sonar/api/notification/ActionBarNotificationHandler.java

@@ -63,10 +63,10 @@ public final class ActionBarNotificationHandler extends NotificationHandler {
       Placeholder.unparsed("verify-total", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalAttemptedVerifications())),
       Placeholder.unparsed("verify-success", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalSuccessfulVerifications())),
       Placeholder.unparsed("verify-failed", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalFailedVerifications())),
-      Placeholder.unparsed("incoming-traffic", Sonar.get().getStatistics().getCurrentIncomingBandwidthFormatted()),
-      Placeholder.unparsed("outgoing-traffic", Sonar.get().getStatistics().getCurrentOutgoingBandwidthFormatted()),
-      Placeholder.unparsed("incoming-traffic-ttl", Sonar.get().getStatistics().getTotalIncomingBandwidthFormatted()),
-      Placeholder.unparsed("outgoing-traffic-ttl", Sonar.get().getStatistics().getTotalOutgoingBandwidthFormatted()),
+      Placeholder.unparsed("incoming-traffic", Sonar.get().getStatistics().getPerSecondIncomingBandwidthFormatted()),
+      Placeholder.unparsed("outgoing-traffic", Sonar.get().getStatistics().getPerSecondOutgoingBandwidthFormatted()),
+      Placeholder.unparsed("incoming-traffic-ttl", formatMemory(Sonar.get().getStatistics().getTotalIncomingBandwidth())),
+      Placeholder.unparsed("outgoing-traffic-ttl", formatMemory(Sonar.get().getStatistics().getTotalOutgoingBandwidth())),
       Placeholder.unparsed("used-memory", formatMemory(getUsedMemory())),
       Placeholder.unparsed("free-memory", formatMemory(getFreeMemory())),
       Placeholder.unparsed("total-memory", formatMemory(getTotalMemory())),

api/src/main/java/xyz/jonesdev/sonar/api/notification/ChatNotificationHandler.java

@@ -63,10 +63,10 @@ public final class ChatNotificationHandler extends NotificationHandler {
         Placeholder.unparsed("verify-total", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalAttemptedVerifications())),
         Placeholder.unparsed("verify-success", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalSuccessfulVerifications())),
         Placeholder.unparsed("verify-failed", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalFailedVerifications())),
-        Placeholder.unparsed("incoming-traffic", Sonar.get().getStatistics().getCurrentIncomingBandwidthFormatted()),
-        Placeholder.unparsed("outgoing-traffic", Sonar.get().getStatistics().getCurrentOutgoingBandwidthFormatted()),
-        Placeholder.unparsed("incoming-traffic-ttl", Sonar.get().getStatistics().getTotalIncomingBandwidthFormatted()),
-        Placeholder.unparsed("outgoing-traffic-ttl", Sonar.get().getStatistics().getTotalOutgoingBandwidthFormatted()),
+        Placeholder.unparsed("incoming-traffic", Sonar.get().getStatistics().getPerSecondIncomingBandwidthFormatted()),
+        Placeholder.unparsed("outgoing-traffic", Sonar.get().getStatistics().getPerSecondOutgoingBandwidthFormatted()),
+        Placeholder.unparsed("incoming-traffic-ttl", formatMemory(Sonar.get().getStatistics().getTotalIncomingBandwidth())),
+        Placeholder.unparsed("outgoing-traffic-ttl", formatMemory(Sonar.get().getStatistics().getTotalOutgoingBandwidth())),
         Placeholder.unparsed("used-memory", formatMemory(getUsedMemory())),
         Placeholder.unparsed("free-memory", formatMemory(getFreeMemory())),
         Placeholder.unparsed("total-memory", formatMemory(getTotalMemory())),

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

@@ -0,0 +1,53 @@
+/*
+ * 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.statistics;
+
+@SuppressWarnings("unused")
+public interface SonarStatistics {
+  long getConnectionsPerSecond();
+
+  long getLoginsPerSecond();
+
+  long getCurrentIncomingBandwidth();
+
+  long getCurrentOutgoingBandwidth();
+
+  long getTotalIncomingBandwidth();
+
+  long getTotalOutgoingBandwidth();
+
+  String getPerSecondIncomingBandwidthFormatted();
+
+  String getPerSecondOutgoingBandwidthFormatted();
+
+  int getTotalPlayersJoined();
+
+  int getTotalPlayersVerified();
+
+  int getTotalSuccessfulVerifications();
+
+  int getTotalFailedVerifications();
+
+  long getCurrentAttemptedVerifications();
+
+  int getTotalAttemptedVerifications();
+
+  long getCurrentBlacklistSize();
+
+  long getTotalBlacklistSize();
+}

api/src/main/java/xyz/jonesdev/sonar/api/update/UpdateChecker.java

@@ -15,10 +15,12 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.common.update;
+package xyz.jonesdev.sonar.api.update;
 
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParser;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
 import lombok.experimental.UtilityClass;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
@@ -35,6 +37,8 @@ import java.util.concurrent.Executors;
 @UtilityClass
 public class UpdateChecker {
   private final ExecutorService ASYNC_EXECUTOR = Executors.newSingleThreadExecutor();
+  @Getter
+  private CheckResult lastCheckResult = CheckResult.UNRESOLVED;
 
   public void checkForUpdates() {
     ASYNC_EXECUTOR.execute(() -> {
@@ -49,15 +53,19 @@ public class UpdateChecker {
         if (convertedCurrentVersion < convertedLatestVersion) {
           Sonar.get().getLogger().warn("A new version of Sonar is available: {}", latestStableRelease);
           Sonar.get().getLogger().warn("Please make sure to update to the latest version to ensure stability and security:");
-          Sonar.get().getLogger().warn("https://github.com/jonesdevelopment/sonar/releases/tag/{}", latestStableRelease);
+          Sonar.get().getLogger().warn("https://github.com/jonesdevelopment/sonar/releases/latest");
+          lastCheckResult = CheckResult.OUTDATED_VERSION;
         } else if (convertedCurrentVersion > convertedLatestVersion || !Sonar.get().getVersion().getGitBranch().equals("main")) {
           Sonar.get().getLogger().warn("You are currently using an unreleased version of Sonar!");
           Sonar.get().getLogger().warn("The contributors of Sonar are not responsible for any damage done by using an unstable version");
-        } else {
+          lastCheckResult = CheckResult.UNSTABLE_VERSION;
+        } else if (lastCheckResult != CheckResult.LATEST_VERSION) {
           Sonar.get().getLogger().info("You are currently using the latest stable release of Sonar!");
+          lastCheckResult = CheckResult.LATEST_VERSION;
         }
       } catch (Throwable throwable) {
         Sonar.get().getLogger().warn("Unable to retrieve version information: {}", throwable);
+        lastCheckResult = CheckResult.API_ERROR;
       }
     });
   }
@@ -99,4 +107,16 @@ public class UpdateChecker {
     final int patch = Integer.parseInt(convertedParts[2]);
     return convertedMajor + convertedMinor + patch; // sum the converted version parts
   }
+
+  @Getter
+  @RequiredArgsConstructor
+  public enum CheckResult {
+    API_ERROR("api-error"),
+    OUTDATED_VERSION("outdated-version"),
+    UNSTABLE_VERSION("unstable-version"),
+    LATEST_VERSION(null),
+    UNRESOLVED(null);
+
+    private final String configKey;
+  }
 }

build.gradle.kts

@@ -86,7 +86,7 @@ allprojects {
 tasks {
   // This is a small wrapper tasks to simplify the building process
   register("build-sonar") {
-    val subprojects = listOf("api", "common", "bukkit", "bungee", "velocity")
+    val subprojects = listOf("api", "captcha", "common", "bukkit", "bungeecord", "velocity")
     val buildTasks = subprojects.flatMap { listOf("$it:clean", "$it:shadowJar") }
     dependsOn(buildTasks)
   }

bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/fallback/FallbackBukkitInboundHandler.java

@@ -34,12 +34,14 @@ import java.net.InetSocketAddress;
 import java.util.Objects;
 
 import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_INBOUND_HANDLER;
-import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.Direction.SERVERBOUND;
 import static xyz.jonesdev.sonar.common.fallback.protocol.packets.handshake.HandshakePacket.*;
 import static xyz.jonesdev.sonar.common.util.ProtocolUtil.DEBUG;
 import static xyz.jonesdev.sonar.common.util.ProtocolUtil.readVarInt;
 
 final class FallbackBukkitInboundHandler extends FallbackInboundHandlerAdapter {
+  private static final ProtocolVersion DEFAULT_PROTOCOL_VERSION = ProtocolVersion.MINECRAFT_1_7_2;
+
+  private FallbackPacketRegistry.ProtocolRegistry registry;
 
   FallbackBukkitInboundHandler() {
     updateRegistry(FallbackPacketRegistry.HANDSHAKE, DEFAULT_PROTOCOL_VERSION);
@@ -53,17 +55,13 @@ final class FallbackBukkitInboundHandler extends FallbackInboundHandlerAdapter {
     };
   }
 
-  private FallbackPacketRegistry.ProtocolRegistry registry;
-
-  private static final ProtocolVersion DEFAULT_PROTOCOL_VERSION = ProtocolVersion.MINECRAFT_1_7_2;
-
   public void updateRegistry(final @NotNull FallbackPacketRegistry registry,
                              final @NotNull ProtocolVersion protocolVersion) {
-    this.registry = registry.getProtocolRegistry(SERVERBOUND, protocolVersion);
+    this.registry = registry.getProtocolRegistry(FallbackPacketRegistry.Direction.SERVERBOUND, protocolVersion);
   }
 
   @Override
-  public void channelRead(final @NotNull ChannelHandlerContext ctx, final @NotNull Object msg) throws Exception {
+  public void channelRead(final @NotNull ChannelHandlerContext ctx, final Object msg) throws Exception {
     if (msg instanceof ByteBuf) {
       final ByteBuf byteBuf = (ByteBuf) msg;
 
@@ -119,7 +117,7 @@ final class FallbackBukkitInboundHandler extends FallbackInboundHandlerAdapter {
           case LOGIN:
           case TRANSFER:
             // Let the actual handler know about the handshake packet
-            handleHandshake(ctx.channel(), handshake.getHostname(), handshake.getProtocolVersionId());
+            handleHandshake(ctx, handshake.getHostname(), handshake.getProtocolVersionId());
             // Be ready for the next packet (which is supposed to be a login packet)
             updateRegistry(FallbackPacketRegistry.LOGIN, Objects.requireNonNull(protocolVersion));
             break;
@@ -132,9 +130,10 @@ final class FallbackBukkitInboundHandler extends FallbackInboundHandlerAdapter {
         // We've done our job - deject this pipeline
         ctx.pipeline().remove(this);
         // Let Sonar process the login packet
-        handleLogin(ctx.channel(), ctx, () -> {
+        handleLogin(ctx, () -> {
           byteBuf.readerIndex(originalReaderIndex);
           ctx.fireChannelRead(byteBuf.retain());
+          // TODO: recode this?
           final ChannelHandler inboundHandler = ctx.pipeline().remove(FALLBACK_INBOUND_HANDLER);
           if (inboundHandler != null) {
             channelRemovalListener.accept(ctx.pipeline(), FALLBACK_INBOUND_HANDLER, inboundHandler);

bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/fallback/FallbackBukkitInjector.java

@@ -26,8 +26,8 @@ import lombok.experimental.UtilityClass;
 import org.bukkit.Bukkit;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.exception.ReflectiveOperationException;
 import xyz.jonesdev.sonar.common.fallback.netty.FallbackInjectedChannelInitializer;
+import xyz.jonesdev.sonar.common.util.exception.ReflectiveOperationException;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;

bungeecord/build.gradle.kts

@@ -26,6 +26,8 @@ dependencies {
 tasks {
   shadowJar {
     relocate("net.kyori", "xyz.jonesdev.sonar.libs.kyori")
+
+    archiveFileName = "Sonar-Bungee.jar" // Hardcode a shortened version of the name
   }
 }
 

bungeecord/src/main/java/xyz/jonesdev/sonar/bungee/fallback/FallbackBungeeInboundHandler.java

@@ -17,7 +17,6 @@
 
 package xyz.jonesdev.sonar.bungee.fallback;
 
-import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import net.md_5.bungee.netty.ChannelWrapper;
 import net.md_5.bungee.netty.HandlerBoss;
@@ -26,8 +25,8 @@ 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.exception.ReflectiveOperationException;
 import xyz.jonesdev.sonar.common.fallback.FallbackInboundHandlerAdapter;
+import xyz.jonesdev.sonar.common.util.exception.ReflectiveOperationException;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
@@ -49,42 +48,42 @@ final class FallbackBungeeInboundHandler extends FallbackInboundHandlerAdapter {
   }
 
   @Override
-  public void channelRead(final @NotNull ChannelHandlerContext ctx, final @NotNull Object msg) throws Exception {
+  public void channelRead(final @NotNull ChannelHandlerContext ctx, final Object msg) throws Exception {
     if (msg instanceof PacketWrapper) {
       final PacketWrapper packetWrapper = (PacketWrapper) msg;
       final DefinedPacket wrappedPacket = packetWrapper.packet;
       // Skip any unknown or invalid packets
       if (wrappedPacket != null) {
-        final Channel channel = ctx.channel();
-        // Intercept any handshake packet by the client
         if (wrappedPacket instanceof Handshake) {
           final Handshake handshake = (Handshake) wrappedPacket;
           // We don't care about server pings; remove the handler
           if (handshake.getRequestedProtocol() == STATUS) {
             ctx.pipeline().remove(this);
           } else {
-            handleHandshake(channel, handshake.getHost(), handshake.getProtocolVersion());
+            handleHandshake(ctx, handshake.getHost(), handshake.getProtocolVersion());
           }
-        }
-        // Intercept any server login packet by the client
-        else if (wrappedPacket instanceof LoginRequest) {
+        } else if (wrappedPacket instanceof LoginRequest) {
           // Make sure to use the potentially modified, real IP
           final LoginRequest loginRequest = (LoginRequest) wrappedPacket;
-          final HandlerBoss handlerBoss = channel.pipeline().get(HandlerBoss.class);
-          final ChannelWrapper channelWrapper;
-          try {
-            channelWrapper = (ChannelWrapper) CHANNEL_WRAPPER_GETTER.invokeExact(handlerBoss);
-          } catch (final Throwable throwable) {
-            throw new ReflectiveOperationException(throwable);
+          final HandlerBoss handlerBoss = ctx.pipeline().get(HandlerBoss.class);
+          // This might sometimes happen if the client unexpectedly disconnects
+          if (handlerBoss != null) {
+            // Get the real IP address of the player through the channel wrapper
+            final ChannelWrapper channelWrapper;
+            try {
+              channelWrapper = (ChannelWrapper) CHANNEL_WRAPPER_GETTER.invokeExact(handlerBoss);
+            } catch (final Throwable throwable) {
+              throw new ReflectiveOperationException(throwable);
+            }
+            // We've done our job - deject this pipeline
+            ctx.pipeline().remove(this);
+            // Make sure to mark this packet as released
+            packetWrapper.trySingleRelease();
+            // Let Sonar process the login packet
+            final InetSocketAddress socketAddress = (InetSocketAddress) channelWrapper.getRemoteAddress();
+            handleLogin(ctx, () -> ctx.fireChannelRead(msg), loginRequest.getData(), socketAddress);
+            return;
           }
-          final InetSocketAddress socketAddress = (InetSocketAddress) channelWrapper.getRemoteAddress();
-          // We've done our job - deject this pipeline
-          ctx.pipeline().remove(this);
-          // Make sure to mark this packet as released
-          packetWrapper.trySingleRelease();
-          // Let Sonar process the login packet
-          handleLogin(channel, ctx, () -> ctx.fireChannelRead(msg), loginRequest.getData(), socketAddress);
-          return;
         }
       }
     }

captcha/src/main/java/xyz/jonesdev/sonar/captcha/StandardCaptchaGenerator.java

@@ -33,8 +33,8 @@ import java.awt.font.FontRenderContext;
 import java.awt.font.GlyphVector;
 import java.awt.geom.AffineTransform;
 import java.awt.image.BufferedImage;
+import java.io.File;
 import java.io.IOException;
-import java.io.InputStream;
 import java.util.Arrays;
 import java.util.Random;
 
@@ -69,12 +69,12 @@ public final class StandardCaptchaGenerator implements CaptchaGenerator {
     }
   }
 
-  private final int width, height;
-  private final @Nullable InputStream background;
-  private BufferedImage backgroundImage;
+  private final int width = 128, height = 128;
+  private final @Nullable File background;
+  private @Nullable BufferedImage backgroundImage;
 
   @Override
-  public @NotNull BufferedImage createImage(final char[] answer) {
+  public @NotNull BufferedImage createImage(final char @NotNull [] answer) {
     final BufferedImage image = createBackgroundImage();
     final Graphics2D graphics = image.createGraphics();
     graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
@@ -91,16 +91,22 @@ public final class StandardCaptchaGenerator implements CaptchaGenerator {
   }
 
   private @NotNull BufferedImage createBackgroundImage() {
+    // Create a new image buffer with a 3-byte color spectrum
+    final BufferedImage image = new BufferedImage(width, height, TYPE_3BYTE_BGR);
     if (background == null) {
-      final BufferedImage image = new BufferedImage(width, height, TYPE_3BYTE_BGR);
       // Fill the entire image with a noise texture
       return FBM.filter(image, image);
     }
-    try {
-      return backgroundImage == null ? backgroundImage = ImageIO.read(background) : backgroundImage;
-    } catch (IOException exception) {
-      throw new IllegalStateException("Could not read background image", exception);
+    // Try to load the image from a file if it doesn't exist yet
+    if (backgroundImage == null) {
+      try {
+        backgroundImage = ImageIO.read(background);
+      } catch (IOException exception) {
+        throw new IllegalStateException("Could not read background image", exception);
+      }
     }
+    image.createGraphics().drawImage(backgroundImage, 0, 0, Color.WHITE, null);
+    return image;
   }
 
   private void applyRandomColorGradient(final @NotNull Graphics2D graphics) {

captcha/src/test/java/Main.java

@@ -28,7 +28,7 @@ import java.util.Random;
 public class Main {
   public void main(final String... args) throws IOException {
     final Random random = new Random();
-    final StandardCaptchaGenerator standardCaptchaGenerator = new StandardCaptchaGenerator(128, 128, null);
+    final StandardCaptchaGenerator standardCaptchaGenerator = new StandardCaptchaGenerator(null);
 
     final long start = System.currentTimeMillis();
     final char[] dictionary = {'a', 'b', 'c', 'd', 'e', 'f'/*, 'g'*/, 'h'/*, 'i'*/, 'j',

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

@@ -39,10 +39,9 @@ import xyz.jonesdev.sonar.api.timer.SystemTimer;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer;
 import xyz.jonesdev.sonar.common.fallback.ratelimit.CaffeineCacheRatelimiter;
 import xyz.jonesdev.sonar.common.fallback.ratelimit.NoopCacheRatelimiter;
-import xyz.jonesdev.sonar.common.service.SonarServiceManager;
+import xyz.jonesdev.sonar.common.service.ScheduledServiceManager;
 import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
 import xyz.jonesdev.sonar.common.subcommand.*;
-import xyz.jonesdev.sonar.common.update.UpdateChecker;
 import xyz.jonesdev.sonar.common.util.ProtocolUtil;
 
 import java.io.File;
@@ -99,13 +98,6 @@ public abstract class SonarBootstrap<T> implements Sonar {
   }
 
   public final void initialize() {
-    // Check if the branch is not the main branch to warn about unstable versions
-    if (!getVersion().getGitBranch().equals("main")) {
-      getLogger().warn("You are currently using an unofficial experimental branch.");
-      getLogger().warn("It is highly recommended to use the latest stable release of Sonar:");
-      getLogger().warn("https://github.com/jonesdevelopment/sonar/releases");
-    }
-
     getLogger().info("Successfully booted in {}s!", launchTimer);
     getLogger().info("Initializing shared components...");
 
@@ -121,7 +113,7 @@ public abstract class SonarBootstrap<T> implements Sonar {
 
       // Start threads
       getLogger().info("Starting all managed threads...");
-      SonarServiceManager.start();
+      ScheduledServiceManager.start();
 
       // Done
       getLogger().info("Done ({}s)!", launchTimer);
@@ -129,12 +121,6 @@ public abstract class SonarBootstrap<T> implements Sonar {
       // An error has occurred
       getLogger().error("An error has occurred while launching Sonar: {}", throwable);
       throwable.printStackTrace(System.err);
-      return; // Do not check for updates if the launch failed
-    }
-
-    // Check if a new version has been released if enabled in the configuration
-    if (Sonar.get().getConfig().getGeneralConfig().getBoolean("general.check-for-updates")) {
-      UpdateChecker.checkForUpdates();
     }
   }
 
@@ -190,7 +176,7 @@ public abstract class SonarBootstrap<T> implements Sonar {
     // Initialize the shutdown process
     getLogger().info("Starting shutdown process...");
     // Interrupt threads
-    SonarServiceManager.stop();
+    ScheduledServiceManager.stop();
     // Close database connection if present
     if (verifiedPlayerController != null) {
       verifiedPlayerController.close();

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

@@ -25,9 +25,7 @@ import io.netty.channel.ChannelPromise;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.jetbrains.annotations.NotNull;
-
-import static xyz.jonesdev.sonar.common.statistics.BandwidthStatistics.INCOMING;
-import static xyz.jonesdev.sonar.common.statistics.BandwidthStatistics.OUTGOING;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
 
 @ChannelHandler.Sharable
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
@@ -35,27 +33,22 @@ 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
+  public void channelRead(final ChannelHandlerContext ctx, final @NotNull Object msg) throws Exception {
     if (msg instanceof ByteBuf) {
       // Increment the incoming traffic by the number of readable bytes
-      INCOMING.increment(((ByteBuf) msg).readableBytes());
+      final int readableBytes = ((ByteBuf) msg).readableBytes();
+      GlobalSonarStatistics.perSecondIncomingTraffic += readableBytes;
     }
-    // Make sure to let the server handle the rest
     ctx.fireChannelRead(msg);
   }
 
   @Override
-  public void write(final @NotNull ChannelHandlerContext ctx,
-                    final @NotNull Object msg,
-                    final ChannelPromise promise) throws Exception {
-    // We can only get the size of a message if it's a ByteBuf
+  public void write(final ChannelHandlerContext ctx, final Object msg, final ChannelPromise promise) throws Exception {
     if (msg instanceof ByteBuf) {
       // Increment the outgoing traffic by the number of readable bytes
-      OUTGOING.increment(((ByteBuf) msg).readableBytes());
+      final int readableBytes = ((ByteBuf) msg).readableBytes();
+      GlobalSonarStatistics.perSecondOutgoingTraffic += readableBytes;
     }
-    // Make sure to let the server handle the rest
     ctx.write(msg, promise);
   }
 }

common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackInboundHandler.java

@@ -41,7 +41,7 @@ public final class FallbackInboundHandler extends ChannelInboundHandlerAdapter {
   public void channelActive(final @NotNull ChannelHandlerContext ctx) throws Exception {
     // Increase connections per second for the action bar verbose
     GlobalSonarStatistics.countConnection();
-    // Make sure to let the server handle the rest
+    // Make sure to let the server handle this
     ctx.fireChannelActive();
     // Add the packet handler pipeline
     sonarPipelineInjector.accept(ctx.pipeline());
@@ -49,26 +49,42 @@ public final class FallbackInboundHandler extends ChannelInboundHandlerAdapter {
 
   @Override
   public void channelInactive(final @NotNull ChannelHandlerContext ctx) throws Exception {
+    // Make sure to let the server handle this
+    ctx.fireChannelInactive();
     // The player can disconnect without sending the login packet first
     // Account for this by checking if the inetAddress has been set yet
     if (inetAddress != null) {
-      // Remove the IP address from the connected players
-      Sonar.get().getFallback().getConnected().compute(inetAddress, (k, v) -> null);
       // Remove the IP address from the queue
-      Sonar.get().getFallback().getQueue().getPlayers().compute(inetAddress, (k, v) -> null);
-      // Remove this account from the online players or decrement the number of accounts with the same IP
-      Sonar.get().getFallback().getOnline().compute(inetAddress, (k, v) -> v == null || v <= 1 ? null : v - 1);
+      Sonar.get().getFallback().getQueue().getPlayers().compute(inetAddress, (ignored, action) -> {
+        // The player is not queued, so we need to remove them from other maps as well
+        if (action == null) {
+          // Remove the IP address from the connected players, if needed
+          Sonar.get().getFallback().getConnected().compute(inetAddress, (__, v) -> {
+            /*
+             * Remove this account from the online players or decrement the number of accounts
+             * with the same IP, but only if the player is logging into the backend server.
+             * We don't need to decrement the count if the player was just verified since
+             * we've never actually incremented it in the first place ¯\_(ツ)_/¯
+             */
+            if (v == null) {
+              Sonar.get().getFallback().getOnline().compute(inetAddress,
+                (ignored1, count) -> count == null || count <= 1 ? null : count - 1);
+            }
+            return null;
+          });
+        }
+        return null;
+      });
     }
-    // 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.
+  /*
+   * We can override the default exceptionCaught method since this handler
+   * will run before the connection knows that there has been an error.
+   */
   @Override
   public void exceptionCaught(final @NotNull ChannelHandlerContext ctx,
                               final @NotNull Throwable cause) throws Exception {
-    // Close the channel if we encounter any errors.
     ctx.close();
   }
 }

common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackInboundHandlerAdapter.java

@@ -23,8 +23,8 @@ 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.FallbackUser;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.api.fingerprint.FingerprintingUtil;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketEncoder;
 import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
@@ -33,15 +33,12 @@ import xyz.jonesdev.sonar.common.util.exception.QuietDecoderException;
 
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
-import java.nio.charset.StandardCharsets;
 import java.util.Map;
-import java.util.Objects;
-import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
 import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.*;
-import static xyz.jonesdev.sonar.common.fallback.FallbackUserWrapper.closeWith;
 import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer.*;
+import static xyz.jonesdev.sonar.common.util.ProtocolUtil.closeWith;
 
 @AllArgsConstructor
 @RequiredArgsConstructor
@@ -52,11 +49,8 @@ public abstract class FallbackInboundHandlerAdapter extends ChannelInboundHandle
 
   /**
    * Validates and handles incoming handshake packets
-   *
-   * @param hostname Hostname (server address) sent by the client
-   * @param protocol Protocol version number sent by the client
    */
-  protected final void handleHandshake(final @NotNull Channel channel,
+  protected final void handleHandshake(final @NotNull ChannelHandlerContext ctx,
                                        final @NotNull String hostname,
                                        final int protocol) throws Exception {
     // Check if the hostname is invalid
@@ -67,23 +61,15 @@ public abstract class FallbackInboundHandlerAdapter extends ChannelInboundHandle
     if (protocolVersion != null) {
       throw QuietDecoderException.INSTANCE;
     }
-    // Store the protocol version
     protocolVersion = ProtocolVersion.fromId(protocol);
-    // Hook the traffic listener
-    channel.pipeline().addFirst(FALLBACK_BANDWIDTH, FallbackBandwidthHandler.INSTANCE);
+    ctx.pipeline().addFirst(FALLBACK_BANDWIDTH, FallbackBandwidthHandler.INSTANCE);
   }
 
   /**
    * Validates and handles incoming login packets
-   *
-   * @param channel       Forwarded client channel
-   * @param loginPacket   Login packet sent by the client
-   * @param username      Username sent by the client
-   * @param socketAddress Socket address of the client
    */
-  protected final void handleLogin(final @NotNull Channel channel,
-                                   final @NotNull ChannelHandlerContext ctx,
-                                   final @NotNull Runnable loginPacket,
+  protected final void handleLogin(final @NotNull ChannelHandlerContext ctx,
+                                   final @NotNull Runnable initialLoginAction,
                                    final @NotNull String username,
                                    final @NotNull InetSocketAddress socketAddress) throws Exception {
     // Check if the player has already sent a login packet
@@ -91,64 +77,63 @@ public abstract class FallbackInboundHandlerAdapter extends ChannelInboundHandle
       throw QuietDecoderException.INSTANCE;
     }
     // Connections from unknown protocol versions will be discarded
-    // as this is the safest way of handling unwanted connections
+    // as this is the safest way of handling unwanted connections.
+    // Sonar does not support snapshots or Minecraft versions older than 1.7.2
     if (protocolVersion.isUnknown()) {
-      // Sonar does not support snapshots or Minecraft versions older than 1.7.2
       throw QuietDecoderException.INSTANCE;
     }
-    // Increase joins per second for the action bar verbose
     GlobalSonarStatistics.countLogin();
-    // Store the username and IP address
     this.username = username;
-    final FallbackInboundHandler inboundHandler = channel.pipeline().get(FallbackInboundHandler.class);
-    Objects.requireNonNull(inboundHandler).setInetAddress(socketAddress.getAddress());
-    final String hostAddress = socketAddress.getAddress().getHostAddress();
+
+    final InetAddress inetAddress = socketAddress.getAddress();
+    ctx.pipeline().get(FallbackInboundHandler.class).setInetAddress(inetAddress);
 
     // Check if Fallback is already verifying a player with the same IP address
-    if (Sonar.get().getFallback().getConnected().containsKey(inboundHandler.getInetAddress())) {
-      customDisconnect(channel, protocolVersion, alreadyVerifying);
+    if (Sonar.get().getFallback().getConnected().containsKey(inetAddress)) {
+      customDisconnect(ctx.channel(), alreadyVerifying, protocolVersion);
       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);
+    if (Sonar.get().getConfig().getVerification().getBlacklistedProtocols().contains(protocolVersion.getProtocol())) {
+      customDisconnect(ctx.channel(), protocolBlacklisted, protocolVersion);
       return;
     }
 
+    final String hostAddress = inetAddress.getHostAddress();
     // Check if the player failed the verification too many times
-    final int score = Sonar.get().getFallback().getBlacklist().asMap().getOrDefault(hostAddress, 0);
     final int limit = Sonar.get().getConfig().getVerification().getBlacklistThreshold();
-    if (score >= limit) {
-      customDisconnect(channel, protocolVersion, blacklisted);
-      return;
+    if (limit > 0) {
+      final int score = Sonar.get().getFallback().getBlacklist().asMap().getOrDefault(hostAddress, 0);
+      if (score >= limit) {
+        customDisconnect(ctx.channel(), blacklisted, protocolVersion);
+        return;
+      }
     }
 
     // Don't continue the verification process if the verification is disabled
     if (!Sonar.get().getFallback().shouldVerifyNewPlayers()) {
-      initialLogin(ctx, inboundHandler.getInetAddress(), loginPacket);
+      initialLogin(ctx.channel(), inetAddress, initialLoginAction);
       return;
     }
 
     // Completely skip Geyser connections if configured
-    final boolean geyser = GeyserUtil.isGeyserConnection(channel, socketAddress);
+    final boolean geyser = GeyserUtil.isGeyserConnection(ctx.channel(), socketAddress);
     if (geyser && !Sonar.get().getConfig().getVerification().isCheckGeyser()) {
-      initialLogin(ctx, inboundHandler.getInetAddress(), loginPacket);
+      initialLogin(ctx.channel(), inetAddress, initialLoginAction);
       return;
     }
 
     // Make sure we actually have to verify the player
-    final String offlineUuidString = "OfflinePlayer:" + username;
-    final UUID offlineUuid = UUID.nameUUIDFromBytes(offlineUuidString.getBytes(StandardCharsets.UTF_8));
-    if (Sonar.get().getVerifiedPlayerController().has(hostAddress, offlineUuid)) {
-      initialLogin(ctx, inboundHandler.getInetAddress(), loginPacket);
+    final String fingerprint = FingerprintingUtil.getFingerprint(username, hostAddress);
+    if (Sonar.get().getVerifiedPlayerController().getCache().contains(fingerprint)) {
+      initialLogin(ctx.channel(), inetAddress, initialLoginAction);
       return;
     }
 
     // Check if the IP address is currently being rate-limited
-    if (!Sonar.get().getFallback().getRatelimiter().attempt(inboundHandler.getInetAddress())) {
-      customDisconnect(channel, protocolVersion, reconnectedTooFast);
+    if (!Sonar.get().getFallback().getRatelimiter().attempt(inetAddress)) {
+      customDisconnect(ctx.channel(), reconnectedTooFast, protocolVersion);
       return;
     }
 
@@ -156,10 +141,10 @@ public abstract class FallbackInboundHandlerAdapter extends ChannelInboundHandle
     rewriteProtocol(ctx, channelRemovalListener);
 
     // Queue the connection for further processing
-    Sonar.get().getFallback().getQueue().getPlayers().compute(inboundHandler.getInetAddress(), (inetAddress, runnable) -> {
+    Sonar.get().getFallback().getQueue().getPlayers().compute(inetAddress, (__, runnable) -> {
       // Check if the player is already queued since we don't want bots to flood the queue
       if (runnable != null) {
-        customDisconnect(channel, protocolVersion, alreadyQueued);
+        customDisconnect(ctx.channel(), alreadyQueued, protocolVersion);
         // Remove other instances of this IP address from the queue
         return null;
       }
@@ -167,21 +152,42 @@ public abstract class FallbackInboundHandlerAdapter extends ChannelInboundHandle
       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(username).matches()) {
-          customDisconnect(channel, protocolVersion, invalidUsername);
+        if (!Sonar.get().getConfig().getVerification().getValidNameRegex().matcher(username).matches()) {
+          customDisconnect(ctx.channel(), invalidUsername, protocolVersion);
           return;
         }
 
-        // Create an instance for the Fallback connection
-        final FallbackUser user = new FallbackUserWrapper(
-          channel, inboundHandler.getInetAddress(), protocolVersion, offlineUuid, geyser);
-        // Let the verification handler take over the channel
-        user.hijack(username, offlineUuid);
+        // Create an instance for the user and let the verification handler take over the channel
+        new FallbackUserWrapper(ctx.channel(), inetAddress, protocolVersion, username, fingerprint, geyser);
       };
     });
   }
 
+  /**
+   * Executes the maximum accounts per IP limit check before letting the player join
+   */
+  protected final void initialLogin(final @NotNull Channel channel,
+                                    final @NotNull InetAddress inetAddress,
+                                    final @NotNull Runnable loginPacket) throws Exception {
+    Sonar.get().getFallback().getOnline().compute(inetAddress, (__, count) -> {
+      final int maxOnlinePerIp = Sonar.get().getConfig().getMaxOnlinePerIp();
+      // Skip the maximum online per IP check if it's disabled in the configuration
+      if (count != null && maxOnlinePerIp > 0) {
+        // Check if the number of online players using the same IP address as
+        // the connecting player is greater than the configured amount
+        if (count >= maxOnlinePerIp) {
+          customDisconnect(channel, tooManyOnlinePerIP, protocolVersion);
+          return count + 1;
+        }
+      }
+
+      // Let the server know about the login packet
+      loginPacket.run();
+      // Increment the number of accounts with the same IP
+      return count == null ? 1 : count + 1;
+    });
+  }
+
   /**
    * Removes all pipelines and rewrites them using our custom handlers
    */
@@ -206,58 +212,24 @@ public abstract class FallbackInboundHandlerAdapter extends ChannelInboundHandle
       TimeUnit.MILLISECONDS));
   }
 
-  /**
-   * Executes the maximum accounts per IP limit check before letting the player join
-   *
-   * @param ctx         Forwarded client channel context
-   * @param inetAddress Resolved client IP address
-   * @param loginPacket Login packet sent by the client
-   */
-  protected final void initialLogin(final @NotNull ChannelHandlerContext ctx,
-                                    final @NotNull InetAddress inetAddress,
-                                    final @NotNull Runnable loginPacket) throws Exception {
-    // Increment the number of accounts with the same IP
-    Sonar.get().getFallback().getOnline().compute(inetAddress, (k, v) -> v == null ? 1 : v + 1);
-
-    final int maxOnlinePerIp = Sonar.get().getConfig().getMaxOnlinePerIp();
-    // Skip the maximum online per IP check if it's disabled in the configuration
-    if (maxOnlinePerIp > 0) {
-      // Check if the number of online players using the same IP address as
-      // the connecting player is greater than the configured amount
-      final int onlinePerIp = Sonar.get().getFallback().getOnline().getOrDefault(inetAddress, 0);
-      if (onlinePerIp >= maxOnlinePerIp) {
-        customDisconnect(ctx.channel(), protocolVersion, tooManyOnlinePerIP);
-        return;
+  private static void customDisconnect(final @NotNull Channel channel,
+                                       final @NotNull FallbackPacket packet,
+                                       final ProtocolVersion protocolVersion) {
+    if (channel.isActive()) {
+      if (channel.eventLoop().inEventLoop()) {
+        _customDisconnect(channel, packet, protocolVersion);
+      } else {
+        channel.eventLoop().execute(() -> _customDisconnect(channel, packet, protocolVersion));
       }
     }
-
-    // Let the server know about the login packet
-    loginPacket.run();
   }
 
   /**
    * Disconnect the player before verification (during login)
-   * by replacing the encoder before running the method.
-   *
-   * @param packet          Disconnect packet
-   * @param channel         Channel of the player
-   * @param protocolVersion Protocol version of the player
    */
-  private void customDisconnect(final @NotNull Channel channel,
-                                final @NotNull ProtocolVersion protocolVersion,
-                                final @NotNull FallbackPacket packet) {
-    if (channel.isActive()) {
-      if (channel.eventLoop().inEventLoop()) {
-        _customDisconnect(channel, protocolVersion, packet);
-      } else {
-        channel.eventLoop().execute(() -> _customDisconnect(channel, protocolVersion, packet));
-      }
-    }
-  }
-
-  private void _customDisconnect(final @NotNull Channel channel,
-                                 final @NotNull ProtocolVersion protocolVersion,
-                                 final @NotNull FallbackPacket packet) {
+  private static void _customDisconnect(final @NotNull Channel channel,
+                                        final @NotNull FallbackPacket packet,
+                                        final ProtocolVersion protocolVersion) {
     // Remove the connection handler pipeline to completely take over the channel
     final String handler = Sonar.get().getPlatform().getConnectionHandler();
     if (channel.pipeline().context(handler) != null) {

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

@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback;
+
+import io.netty.channel.Channel;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+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.api.timer.SystemTimer;
+import xyz.jonesdev.sonar.common.fallback.netty.FallbackTailExceptionsHandler;
+import xyz.jonesdev.sonar.common.fallback.netty.FallbackVarInt21FrameDecoder;
+import xyz.jonesdev.sonar.common.fallback.netty.FallbackVarIntLengthEncoder;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketDecoder;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketEncoder;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.DisconnectPacket;
+import xyz.jonesdev.sonar.common.fallback.verification.FallbackPreJoinHandler;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
+
+import java.net.InetAddress;
+
+import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.*;
+import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT_1_20_2;
+import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.CONFIG;
+import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.GAME;
+import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer.loginSuccess;
+import static xyz.jonesdev.sonar.common.util.ProtocolUtil.closeWith;
+
+@Getter
+@ToString(of = {"protocolVersion", "inetAddress", "geyser"})
+public final class FallbackUserWrapper implements FallbackUser {
+  @Accessors(fluent = true)
+  private final Channel channel;
+  private final InetAddress inetAddress;
+  private final ProtocolVersion protocolVersion;
+  private final String fingerprint;
+  private final String username;
+  private final boolean geyser;
+  private final SystemTimer loginTimer;
+  @Setter
+  private boolean forceCaptcha;
+
+  public FallbackUserWrapper(final @NotNull Channel channel,
+                             final @NotNull InetAddress inetAddress,
+                             final @NotNull ProtocolVersion protocolVersion,
+                             final @NotNull String username,
+                             final @NotNull String fingerprint,
+                             final boolean geyser) {
+    this.channel = channel;
+    this.inetAddress = inetAddress;
+    this.protocolVersion = protocolVersion;
+    this.username = username;
+    this.fingerprint = fingerprint;
+    this.geyser = geyser;
+    this.loginTimer = new SystemTimer();
+
+    GlobalSonarStatistics.totalAttemptedVerifications++;
+
+    if (Sonar.get().getConfig().getVerification().isLogConnections()
+      && (Sonar.get().getAttackTracker().getCurrentAttack() == null
+      || Sonar.get().getConfig().getVerification().isLogDuringAttack())) {
+      Sonar.get().getLogger().info(
+        Sonar.get().getConfig().getMessagesConfig().getString("verification.logs.connection")
+          .replace("<username>", 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));
+
+    // Run this in the channel's event loop to avoid issues
+    channel.eventLoop().execute(() -> {
+      // Make sure the channel is still active
+      if (!channel.isActive()) {
+        return;
+      }
+
+      // Mark the player as connected by caching them in a map of verifying players
+      Sonar.get().getFallback().getConnected().compute(inetAddress, (__, v) -> true);
+
+      // Replace normal encoder to allow custom packets
+      final FallbackPacketEncoder newEncoder = new FallbackPacketEncoder(protocolVersion);
+      channel.pipeline().addFirst(FALLBACK_FRAME_ENCODER, FallbackVarIntLengthEncoder.INSTANCE);
+      channel.pipeline().addLast(FALLBACK_PACKET_ENCODER, newEncoder);
+
+      // Send LoginSuccess packet to make the client think they are joining the server
+      write(loginSuccess);
+
+      // The LoginSuccess packet has been sent, now we can change the registry state
+      newEncoder.updateRegistry(protocolVersion.compareTo(MINECRAFT_1_20_2) >= 0 ? CONFIG : GAME);
+
+      // Replace normal decoder to allow custom packets
+      final FallbackPacketDecoder newDecoder = new FallbackPacketDecoder(protocolVersion);
+      channel.pipeline().addFirst(FALLBACK_FRAME_DECODER, new FallbackVarInt21FrameDecoder());
+      channel.pipeline().addLast(FALLBACK_PACKET_DECODER, newDecoder);
+      // Listen for all incoming packets by setting the packet listener
+      newDecoder.setListener(new FallbackPreJoinHandler(this));
+
+      // Make sure to catch all exceptions during the verification
+      channel.pipeline().addLast(FALLBACK_TAIL_EXCEPTIONS, FallbackTailExceptionsHandler.INSTANCE);
+    });
+  }
+
+  @Override
+  public void disconnect(final @NotNull Component reason) {
+    final FallbackPacketEncoder encoder = channel.pipeline().get(FallbackPacketEncoder.class);
+    final boolean duringLogin = encoder != null && encoder.getPacketRegistry() != GAME;
+    closeWith(channel, protocolVersion, DisconnectPacket.create(reason, duringLogin));
+  }
+}

common/src/main/java/xyz/jonesdev/sonar/common/fallback/netty/FallbackInjectedChannelInitializer.java

@@ -24,9 +24,9 @@ import lombok.RequiredArgsConstructor;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.SonarPlatform;
-import xyz.jonesdev.sonar.api.exception.ReflectiveOperationException;
 import xyz.jonesdev.sonar.common.fallback.FallbackInboundHandler;
 import xyz.jonesdev.sonar.common.util.FakeChannelUtil;
+import xyz.jonesdev.sonar.common.util.exception.ReflectiveOperationException;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;

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

@@ -30,6 +30,7 @@ import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT
 import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.Direction.SERVERBOUND;
 import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.GAME;
 import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.LOGIN;
+import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer.maxTotalPacketsSent;
 import static xyz.jonesdev.sonar.common.util.ProtocolUtil.DEBUG;
 import static xyz.jonesdev.sonar.common.util.ProtocolUtil.readVarInt;
 
@@ -38,6 +39,7 @@ public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
   private FallbackPacketRegistry.ProtocolRegistry registry;
   @Setter
   private FallbackPacketListener listener;
+  private int totalPacketsSent;
 
   public FallbackPacketDecoder(final @NotNull ProtocolVersion protocolVersion) {
     this.protocolVersion = protocolVersion;
@@ -62,6 +64,11 @@ public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
           return;
         }
 
+        // Don't allow the player to spam packets to overload netty
+        if (++totalPacketsSent > maxTotalPacketsSent) {
+          throw DEBUG ? new DecoderException("Sent too many packets") : QuietDecoderException.INSTANCE;
+        }
+
         // Read the packet ID and then create the packet from it
         final int packetId = readVarInt(byteBuf);
         final FallbackPacket packet = registry.createPacket(packetId);
@@ -89,10 +96,9 @@ public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
         // Let our verification handler process the packet
         if (listener != null) {
           listener.handle(packet);
+          // Make sure to let the timeout handler know about this packet
+          ctx.fireChannelRead(packet);
         }
-
-        // Fire channel read to avoid timeout
-        ctx.fireChannelRead(packet);
       } finally {
         // Release the ByteBuf to avoid memory leaks
         byteBuf.release();
@@ -102,14 +108,14 @@ public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
 
   private void checkPacketSize(final @NotNull ByteBuf byteBuf,
                                final @NotNull FallbackPacket packet) throws Exception {
+    final int packetSize = byteBuf.readableBytes();
     final int expectedMaxLen = packet.expectedMaxLength(byteBuf, protocolVersion);
-    if (expectedMaxLen != -1 && byteBuf.readableBytes() > expectedMaxLen) {
-      throw DEBUG ? new DecoderException("Packet too large") : QuietDecoderException.INSTANCE;
+    if (expectedMaxLen != -1 && packetSize > expectedMaxLen) {
+      throw DEBUG ? new DecoderException("Packet too large: " + packetSize) : QuietDecoderException.INSTANCE;
     }
-
     final int expectedMinLen = packet.expectedMinLength(byteBuf, protocolVersion);
-    if (expectedMinLen != -1 && byteBuf.readableBytes() < expectedMinLen) {
-      throw DEBUG ? new DecoderException("Packet too small") : QuietDecoderException.INSTANCE;
+    if (expectedMinLen != -1 && packetSize < expectedMinLen) {
+      throw DEBUG ? new DecoderException("Packet too small: " + packetSize) : QuietDecoderException.INSTANCE;
     }
   }
 }

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

@@ -50,7 +50,7 @@ public final class FallbackPacketEncoder extends MessageToByteEncoder<FallbackPa
                         final ByteBuf out) throws Exception {
     final FallbackPacket originalPacket = packet instanceof FallbackPacketSnapshot
       ? ((FallbackPacketSnapshot) packet).getOriginalPacket() : packet;
-    final int packetId = protocolRegistry.getPacketId(originalPacket);
+    final int packetId = protocolRegistry.getPacketId(originalPacket.getClass());
     writeVarInt(out, packetId);
     packet.encode(out, protocolVersion);
   }

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

@@ -20,8 +20,8 @@ package xyz.jonesdev.sonar.common.fallback.protocol;
 import io.netty.util.collection.IntObjectHashMap;
 import io.netty.util.collection.IntObjectMap;
 import lombok.AccessLevel;
-import lombok.Data;
 import lombok.RequiredArgsConstructor;
+import lombok.ToString;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.configuration.FinishConfigurationPacket;
@@ -32,7 +32,10 @@ import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginStartPacke
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginSuccessPacket;
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;
 
-import java.util.*;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.function.Supplier;
 
 import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.*;
@@ -64,11 +67,11 @@ public enum FallbackPacketRegistry {
         map(0x01, MINECRAFT_1_20_2, true),
         map(0x02, MINECRAFT_1_20_5, true));
       clientbound.register(FinishConfigurationPacket.class, FinishConfigurationPacket::new,
-        map(0x02, MINECRAFT_1_20_2, false),
-        map(0x03, MINECRAFT_1_20_5, false));
+        map(0x02, MINECRAFT_1_20_2, true),
+        map(0x03, MINECRAFT_1_20_5, true));
       clientbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
-        map(0x03, MINECRAFT_1_20_2, false),
-        map(0x04, MINECRAFT_1_20_5, false));
+        map(0x03, MINECRAFT_1_20_2, true),
+        map(0x04, MINECRAFT_1_20_5, true));
       clientbound.register(RegistryDataPacket.class, RegistryDataPacket::new,
         map(0x05, MINECRAFT_1_20_2, true),
         map(0x07, MINECRAFT_1_20_5, true));
@@ -104,20 +107,20 @@ public enum FallbackPacketRegistry {
         map(0x29, MINECRAFT_1_20_2, true),
         map(0x2B, MINECRAFT_1_20_5, true));
       clientbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
-        map(0x00, MINECRAFT_1_7_2, false),
-        map(0x1F, MINECRAFT_1_9, false),
-        map(0x21, MINECRAFT_1_13, false),
-        map(0x20, MINECRAFT_1_14, false),
-        map(0x21, MINECRAFT_1_15, false),
-        map(0x20, MINECRAFT_1_16, false),
-        map(0x1F, MINECRAFT_1_16_2, false),
-        map(0x21, MINECRAFT_1_17, false),
-        map(0x1E, MINECRAFT_1_19, false),
-        map(0x20, MINECRAFT_1_19_1, false),
-        map(0x1F, MINECRAFT_1_19_3, false),
-        map(0x23, MINECRAFT_1_19_4, false),
-        map(0x24, MINECRAFT_1_20_2, false),
-        map(0x26, MINECRAFT_1_20_5, false));
+        map(0x00, MINECRAFT_1_7_2, true),
+        map(0x1F, MINECRAFT_1_9, true),
+        map(0x21, MINECRAFT_1_13, true),
+        map(0x20, MINECRAFT_1_14, true),
+        map(0x21, MINECRAFT_1_15, true),
+        map(0x20, MINECRAFT_1_16, true),
+        map(0x1F, MINECRAFT_1_16_2, true),
+        map(0x21, MINECRAFT_1_17, true),
+        map(0x1E, MINECRAFT_1_19, true),
+        map(0x20, MINECRAFT_1_19_1, true),
+        map(0x1F, MINECRAFT_1_19_3, true),
+        map(0x23, MINECRAFT_1_19_4, true),
+        map(0x24, MINECRAFT_1_20_2, true),
+        map(0x26, MINECRAFT_1_20_5, true));
       clientbound.register(DisconnectPacket.class, DisconnectPacket::new,
         map(0x40, MINECRAFT_1_7_2, true),
         map(0x1A, MINECRAFT_1_9, true),
@@ -213,6 +216,20 @@ public enum FallbackPacketRegistry {
         map(0x5B, MINECRAFT_1_20_2, true),
         map(0x5D, MINECRAFT_1_20_3, true),
         map(0x5F, MINECRAFT_1_20_5, true));
+      clientbound.register(VehicleMovePacket.class, VehicleMovePacket::new,
+        map(0x29, MINECRAFT_1_9, true),
+        map(0x2B, MINECRAFT_1_13, true),
+        map(0x2C, MINECRAFT_1_14, true),
+        map(0x2D, MINECRAFT_1_15, true),
+        map(0x2C, MINECRAFT_1_16, true),
+        map(0x2B, MINECRAFT_1_16_2, true),
+        map(0x2C, MINECRAFT_1_17, true),
+        map(0x29, MINECRAFT_1_19, true),
+        map(0x2B, MINECRAFT_1_19_1, true),
+        map(0x2A, MINECRAFT_1_19_3, true),
+        map(0x2E, MINECRAFT_1_19_4, true),
+        map(0x2F, MINECRAFT_1_20_2, true),
+        map(0x31, MINECRAFT_1_20_5, true));
       clientbound.register(SpawnEntityPacket.class, SpawnEntityPacket::new,
         map(0x0E, MINECRAFT_1_7_2, true),
         map(0x00, MINECRAFT_1_9, true),
@@ -306,19 +323,19 @@ public enum FallbackPacketRegistry {
         map(0x5A, MINECRAFT_1_20_3, true),
         map(0x5C, MINECRAFT_1_20_5, true));
       clientbound.register(SystemChatPacket.class, SystemChatPacket::new,
-        map(0x02, MINECRAFT_1_7_2, false),
-        map(0x0F, MINECRAFT_1_9, false),
-        map(0x0E, MINECRAFT_1_13, false),
-        map(0x0F, MINECRAFT_1_15, false),
-        map(0x0E, MINECRAFT_1_16, false),
-        map(0x0F, MINECRAFT_1_17, false),
-        map(0x5F, MINECRAFT_1_19, false),
-        map(0x62, MINECRAFT_1_19_1, false),
-        map(0x60, MINECRAFT_1_19_3, false),
-        map(0x64, MINECRAFT_1_19_4, false),
-        map(0x67, MINECRAFT_1_20_2, false),
-        map(0x69, MINECRAFT_1_20_3, false),
-        map(0x6C, MINECRAFT_1_20_5, false));
+        map(0x02, MINECRAFT_1_7_2, true),
+        map(0x0F, MINECRAFT_1_9, true),
+        map(0x0E, MINECRAFT_1_13, true),
+        map(0x0F, MINECRAFT_1_15, true),
+        map(0x0E, MINECRAFT_1_16, true),
+        map(0x0F, MINECRAFT_1_17, true),
+        map(0x5F, MINECRAFT_1_19, true),
+        map(0x62, MINECRAFT_1_19_1, true),
+        map(0x60, MINECRAFT_1_19_3, true),
+        map(0x64, MINECRAFT_1_19_4, true),
+        map(0x67, MINECRAFT_1_20_2, true),
+        map(0x69, MINECRAFT_1_20_3, true),
+        map(0x6C, MINECRAFT_1_20_5, true));
       clientbound.register(GameEventPacket.class, GameEventPacket::new,
         map(0x20, MINECRAFT_1_20_3, true),
         map(0x22, MINECRAFT_1_20_5, true));
@@ -341,6 +358,33 @@ public enum FallbackPacketRegistry {
         map(0x4F, MINECRAFT_1_20_2, true),
         map(0x51, MINECRAFT_1_20_3, true),
         map(0x53, MINECRAFT_1_20_5, true));
+      clientbound.register(EntityAnimationPacket.class, EntityAnimationPacket::new,
+        map(0x0B, MINECRAFT_1_7_2, true),
+        map(0x06, MINECRAFT_1_9, true),
+        map(0x05, MINECRAFT_1_16, true),
+        map(0x06, MINECRAFT_1_17, true),
+        map(0x03, MINECRAFT_1_19, true),
+        map(0x04, MINECRAFT_1_19_4, true),
+        map(0x03, MINECRAFT_1_20_2, true));
+      clientbound.register(TeleportEntityPacket.class, TeleportEntityPacket::new,
+        map(0x18, MINECRAFT_1_7_2, true),
+        map(0x4A, MINECRAFT_1_9, true),
+        map(0x49, MINECRAFT_1_9_4, true),
+        map(0x4B, MINECRAFT_1_12, true),
+        map(0x4C, MINECRAFT_1_12_1, true),
+        map(0x50, MINECRAFT_1_13, true),
+        map(0x56, MINECRAFT_1_14, true),
+        map(0x57, MINECRAFT_1_15, true),
+        map(0x56, MINECRAFT_1_16, true),
+        map(0x61, MINECRAFT_1_17, true),
+        map(0x62, MINECRAFT_1_18, true),
+        map(0x63, MINECRAFT_1_19, true),
+        map(0x66, MINECRAFT_1_19_1, true),
+        map(0x64, MINECRAFT_1_19_3, true),
+        map(0x68, MINECRAFT_1_19_4, true),
+        map(0x6B, MINECRAFT_1_20_2, true),
+        map(0x6D, MINECRAFT_1_20_3, true),
+        map(0x70, MINECRAFT_1_20_5, true));
 
       serverbound.register(SetHeldItemPacket.class, SetHeldItemPacket::new,
         map(0x09, MINECRAFT_1_7_2, false),
@@ -385,6 +429,21 @@ public enum FallbackPacketRegistry {
         map(0x22, MINECRAFT_1_20_2, false),
         map(0x23, MINECRAFT_1_20_3, false),
         map(0x26, MINECRAFT_1_20_5, false));
+      serverbound.register(VehicleMovePacket.class, VehicleMovePacket::new,
+        map(0x10, MINECRAFT_1_9, false),
+        map(0x11, MINECRAFT_1_12, false),
+        map(0x10, MINECRAFT_1_12_1, false),
+        map(0x13, MINECRAFT_1_13, false),
+        map(0x15, MINECRAFT_1_14, false),
+        map(0x16, MINECRAFT_1_16, false),
+        map(0x15, MINECRAFT_1_17, false),
+        map(0x17, MINECRAFT_1_19, false),
+        map(0x18, MINECRAFT_1_19_1, false),
+        map(0x17, MINECRAFT_1_19_3, false),
+        map(0x18, MINECRAFT_1_19_4, false),
+        map(0x1A, MINECRAFT_1_20_2, false),
+        map(0x1B, MINECRAFT_1_20_3, false),
+        map(0x1E, MINECRAFT_1_20_5, false));
       serverbound.register(SystemChatPacket.class, SystemChatPacket::new,
         map(0x01, MINECRAFT_1_7_2, false),
         map(0x02, MINECRAFT_1_9, false),
@@ -518,6 +577,19 @@ public enum FallbackPacketRegistry {
         map(0x23, MINECRAFT_1_20_2, false),
         map(0x24, MINECRAFT_1_20_3, false),
         map(0x27, MINECRAFT_1_20_5, false));
+      serverbound.register(AnimationPacket.class, AnimationPacket::new,
+        map(0x0A, MINECRAFT_1_7_2, false),
+        map(0x1A, MINECRAFT_1_9, false),
+        map(0x1D, MINECRAFT_1_12, false),
+        map(0x27, MINECRAFT_1_13, false),
+        map(0x2A, MINECRAFT_1_14, false),
+        map(0x2B, MINECRAFT_1_16, false),
+        map(0x2C, MINECRAFT_1_16_2, false),
+        map(0x2E, MINECRAFT_1_19, false),
+        map(0x2F, MINECRAFT_1_19_1, false),
+        map(0x32, MINECRAFT_1_20_2, false),
+        map(0x33, MINECRAFT_1_20_3, false),
+        map(0x36, MINECRAFT_1_20_5, false));
     }
   };
 
@@ -534,30 +606,28 @@ public enum FallbackPacketRegistry {
     return (direction == Direction.SERVERBOUND ? serverbound : clientbound).getProtocolRegistry(version);
   }
 
-  public static class PacketRegistry {
-    private final Map<ProtocolVersion, ProtocolRegistry> versions;
+  public static final class PacketRegistry {
+    private final Map<ProtocolVersion, ProtocolRegistry> registries = new EnumMap<>(ProtocolVersion.class);
 
     PacketRegistry() {
-      final Map<ProtocolVersion, ProtocolRegistry> mutableVersions = new EnumMap<>(ProtocolVersion.class);
-      for (final ProtocolVersion version : ProtocolVersion.values()) {
-        if (!version.isUnknown()) {
-          mutableVersions.put(version, new ProtocolRegistry(version));
+      for (final ProtocolVersion protocolVersion : ProtocolVersion.values()) {
+        if (!protocolVersion.isUnknown()) {
+          registries.put(protocolVersion, new ProtocolRegistry(protocolVersion));
         }
       }
-      this.versions = Collections.unmodifiableMap(mutableVersions);
     }
 
-    ProtocolRegistry getProtocolRegistry(final ProtocolVersion version) {
-      final ProtocolRegistry registry = versions.get(version);
+    private @NotNull ProtocolRegistry getProtocolRegistry(final @NotNull ProtocolVersion protocolVersion) {
+      final ProtocolRegistry registry = registries.get(protocolVersion);
       if (registry == null) {
-        throw new IllegalArgumentException("Could not find data for protocol version " + version);
+        throw new IllegalArgumentException("Could not find data for protocol version " + protocolVersion);
       }
       return registry;
     }
 
-    <P extends FallbackPacket> void register(final Class<P> clazz,
-                                             final Supplier<P> packetSupplier,
-                                             final PacketMapping @NotNull ... mappings) {
+    private <T extends FallbackPacket> void register(final @NotNull Class<T> clazz,
+                                                     final @NotNull Supplier<T> supplier,
+                                                     final PacketMapping @NotNull ... mappings) {
       if (mappings.length == 0) {
         throw new IllegalArgumentException("At least one mapping must be provided.");
       }
@@ -567,21 +637,21 @@ public enum FallbackPacketRegistry {
         final PacketMapping next = (i + 1 < mappings.length) ? mappings[i + 1] : current;
 
         final ProtocolVersion from = current.protocolVersion;
-        final ProtocolVersion to = getProtocolVersion(current, next);
+        final ProtocolVersion to = current == next ? LATEST_VERSION : next.protocolVersion;
 
-        for (final ProtocolVersion protocol : EnumSet.range(from, to)) {
-          if (protocol == to && next != current) {
+        for (final ProtocolVersion protocolVersion : EnumSet.range(from, to)) {
+          if (protocolVersion == to && next != current) {
             break;
           }
 
-          final ProtocolRegistry registry = versions.get(protocol);
+          final ProtocolRegistry registry = registries.get(protocolVersion);
           if (registry == null) {
-            throw new IllegalArgumentException("Unknown protocol version " + from);
+            throw new IllegalArgumentException("Unknown protocol version " + protocolVersion);
           }
 
-          if (registry.packetIdToSupplier.containsKey(current.id)) {
+          if (registry.packetIdToSupplier.containsKey(current.packetId)) {
             throw new IllegalArgumentException("Can not register class " + clazz.getSimpleName()
-              + " with id " + current.id + " for " + registry.protocolVersion
+              + " with id " + current.packetId + " for " + registry.protocolVersion
               + " because another packet is already registered");
           }
 
@@ -591,18 +661,12 @@ public enum FallbackPacketRegistry {
           }
 
           if (!current.encodeOnly) {
-            registry.packetIdToSupplier.put(current.id, packetSupplier);
+            registry.packetIdToSupplier.put(current.packetId, supplier);
           }
-          registry.packetClassToId.put(clazz, current.id);
+          registry.packetClassToId.put(clazz, current.packetId);
         }
       }
     }
-
-    @NotNull
-    private static ProtocolVersion getProtocolVersion(final @NotNull PacketMapping current,
-                                                      final @NotNull PacketMapping next) {
-      return current == next ? LATEST_VERSION : next.protocolVersion;
-    }
   }
 
   @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
@@ -613,43 +677,38 @@ public enum FallbackPacketRegistry {
     private final Map<Class<? extends FallbackPacket>, Integer> packetClassToId =
       new HashMap<>(16, 0.5f);
 
-    public FallbackPacket createPacket(final int id) {
-      final Supplier<? extends FallbackPacket> supplier = packetIdToSupplier.get(id);
-
-      if (supplier == null) {
-        return null;
-      }
-      return supplier.get();
+    public FallbackPacket createPacket(final int packetId) {
+      final var supplier = packetIdToSupplier.get(packetId);
+      return supplier == null ? null : supplier.get();
     }
 
-    public int getPacketId(final @NotNull FallbackPacket packet) {
-      final int id = packetClassToId.getOrDefault(packet.getClass(), Integer.MIN_VALUE);
-
-      if (id == Integer.MIN_VALUE) {
-        throw new IllegalArgumentException("Could not find packet");
+    public int getPacketId(final @NotNull Class<? extends FallbackPacket> clazz) {
+      final int packetId = packetClassToId.getOrDefault(clazz, -1);
+      if (packetId == -1) {
+        throw new IllegalArgumentException("Could not find packet ID for " + clazz.getSimpleName());
       }
-      return id;
+      return packetId;
     }
   }
 
-  @Data
+  @ToString
   public static final class PacketMapping {
-    private final int id;
+    private final int packetId;
     private final ProtocolVersion protocolVersion;
     private final boolean encodeOnly;
 
-    PacketMapping(final int id,
+    PacketMapping(final int packetId,
                   final ProtocolVersion protocolVersion,
                   final boolean encodeOnly) {
-      this.id = id;
+      this.packetId = packetId;
       this.protocolVersion = protocolVersion;
       this.encodeOnly = encodeOnly;
     }
   }
 
-  private static @NotNull PacketMapping map(final int id,
+  private static @NotNull PacketMapping map(final int packetId,
                                             final ProtocolVersion protocolVersion,
                                             final boolean encodeOnly) {
-    return new PacketMapping(id, protocolVersion, encodeOnly);
+    return new PacketMapping(packetId, protocolVersion, encodeOnly);
   }
 }

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

@@ -18,10 +18,13 @@
 package xyz.jonesdev.sonar.common.fallback.protocol;
 
 import lombok.experimental.UtilityClass;
+import net.kyori.adventure.nbt.CompoundBinaryTag;
+import net.kyori.adventure.nbt.IntBinaryTag;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
+import xyz.jonesdev.sonar.api.event.impl.CaptchaGenerationStartEvent;
 import xyz.jonesdev.sonar.captcha.StandardCaptchaGenerator;
 import xyz.jonesdev.sonar.common.fallback.protocol.block.BlockType;
 import xyz.jonesdev.sonar.common.fallback.protocol.block.BlockUpdate;
@@ -40,41 +43,51 @@ import java.util.UUID;
 @UtilityClass
 public class FallbackPreparer {
   private final Random RANDOM = new Random();
-  // LoginSuccess
-  public FallbackPacket loginSuccess;
-  // Abilities
-  public final FallbackPacket DEFAULT_ABILITIES = new FallbackPacketSnapshot(new PlayerAbilitiesPacket(0x00, 0f, 0f));
-  public final FallbackPacket CAPTCHA_ABILITIES = new FallbackPacketSnapshot(new PlayerAbilitiesPacket(0x02, 0f, 0f));
-  public final FallbackPacket CAPTCHA_ABILITIES_BEDROCK = new FallbackPacketSnapshot(new PlayerAbilitiesPacket(0x06, 0f, 0f));
-  // Chunks
+
+  public static final int PLAYER_ENTITY_ID = RANDOM.nextInt();
+  public static final int VEHICLE_ENTITY_ID = RANDOM.nextInt();
+
+  public static final CompoundBinaryTag MAP_ITEM_NBT = CompoundBinaryTag.builder()
+    .put("map", IntBinaryTag.intBinaryTag(0)) // map type
+    .build();
+
+  public static final BlockType[] POSSIBLE_BLOCK_TYPES = BlockType.values();
+  public final FallbackPacket[] BLOCKS_PACKETS = new FallbackPacket[POSSIBLE_BLOCK_TYPES.length];
+
+  public final int BLOCKS_PER_ROW = 8; // 8 * 8 = 64 (vanilla protocol maximum)
+  public final int SPAWN_X_POSITION = 16 / 2; // middle of the chunk
+  public final int SPAWN_Z_POSITION = 16 / 2; // middle of the chunk
+  public final int DEFAULT_Y_COLLIDE_POSITION = 1 + RANDOM.nextInt(255); // 255 is the maximum Y position
+  public final int IN_AIR_Y_POSITION = 1000 + RANDOM.nextInt(338); // High altitude (randomized)
+  public final int IN_VOID_Y_POSITION = -(120 + RANDOM.nextInt(120)); // Low altitude (randomized)
+
+  public final int FIRST_TELEPORT_ID = RANDOM.nextInt();
+  public final int SECOND_TELEPORT_ID = RANDOM.nextInt();
+
+  public final FallbackPacket DEFAULT_ABILITIES = new PlayerAbilitiesPacket(0x00, 0, 0);
+  public final FallbackPacket NO_MOVE_ABILITIES = new PlayerAbilitiesPacket(0x02, 0, 0);
+  public final FallbackPacket NO_MOVE_ABILITIES_BEDROCK = new PlayerAbilitiesPacket(0x06, 0, 0);
+  public final FallbackPacket CAPTCHA_POSITION = new FallbackPacketSnapshot(new SetPlayerPositionRotationPacket(
+    SPAWN_X_POSITION, IN_AIR_Y_POSITION, SPAWN_Z_POSITION, 0, 90, 0, 0, false));
   public final FallbackPacket EMPTY_CHUNK_DATA = new FallbackPacketSnapshot(new ChunkDataPacket(0, 0));
-  // Finish Configuration
-  public final FallbackPacket FINISH_CONFIGURATION = new FinishConfigurationPacket(); // No snapshot needed because it's empty either way
-  // Synchronize Registry
+  public final FallbackPacket FINISH_CONFIGURATION = new FinishConfigurationPacket();
   public final FallbackPacket REGISTRY_SYNC_LEGACY = new FallbackPacketSnapshot(new RegistryDataPacket(DimensionRegistry.CODEC_1_20, null, null));
   public final FallbackPacket[] REGISTRY_SYNC_1_20_5 = RegistryDataPacket.of(DimensionRegistry.CODEC_1_20);
   public final FallbackPacket[] REGISTRY_SYNC_1_21 = RegistryDataPacket.of(DimensionRegistry.CODEC_1_21);
-  // Keep Alive
-  public final FallbackPacket CAPTCHA_KEEP_ALIVE = new FallbackPacketSnapshot(new KeepAlivePacket(-1337L));
-  // Game Event (1.20.3+)
-  public final FallbackPacket START_WRITING_CHUNKS = new FallbackPacketSnapshot(new GameEventPacket(13, 0));
-  // Chat
+  public final FallbackPacket START_WRITING_CHUNKS = new GameEventPacket(13, 0);
+  public final static FallbackPacket CACHED_HELD_ITEM_SLOT = new SetHeldItemPacket(~4);
+  public final FallbackPacket CAPTCHA_KEEP_ALIVE = new KeepAlivePacket(RANDOM.nextInt());
+
+  public static FallbackPacket loginSuccess;
+  public FallbackPacket welcomeMessage;
   public FallbackPacket enterCodeMessage;
   public FallbackPacket incorrectCaptcha;
-  // JoinGame
-  public final int PLAYER_ENTITY_ID = RANDOM.nextInt(10);
-  public FallbackPacket joinGame;
-  // Update Section Blocks
-  public FallbackPacket updateSectionBlocks;
-  // Default Spawn Position
+  public static FallbackPacket joinGame;
   public FallbackPacket defaultSpawnPosition;
-  // Spawn Position
-  public final int TELEPORT_ID = RANDOM.nextInt();
   public FallbackPacket spawnPosition;
-  // Transfer packet
+  public FallbackPacket fallStartPosition;
+  public FallbackPacket fallStartPositionLegacy;
   public static FallbackPacket transferToOrigin;
-
-  // Disconnect messages
   public FallbackPacket blacklisted;
   public FallbackPacket alreadyQueued;
   public FallbackPacket alreadyVerifying;
@@ -82,32 +95,15 @@ public class FallbackPreparer {
   public FallbackPacket protocolBlacklisted;
   public FallbackPacket invalidUsername;
   public FallbackPacket tooManyOnlinePerIP;
-
-  // Vehicle
-  public FallbackPacket removeEntities;
-  public FallbackPacket spawnEntity;
-  public static FallbackPacket setPassengers;
-  public static final int VEHICLE_ENTITY_ID = PLAYER_ENTITY_ID + 1 + RANDOM.nextInt(10);
-
-  // 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
-  public final int SPAWN_Z_POSITION = 16 / 2; // middle of the chunk
-  public final int DEFAULT_Y_COLLIDE_POSITION = 155 + RANDOM.nextInt(101); // 255 is the maximum Y position
-  public final int IN_AIR_Y_POSITION = 1337;
-
-  // CAPTCHA position
-  public final FallbackPacket CAPTCHA_POSITION = new FallbackPacketSnapshot(new SetPlayerPositionRotationPacket(
-    SPAWN_X_POSITION, IN_AIR_Y_POSITION, SPAWN_Z_POSITION, 0, 90, 0, false));
-
-  // Platform
-  public BlockType blockType;
-  public int maxMovementTick, dynamicSpawnYPosition;
-  public double maxFallDistance;
-
-  // XP packets
+  public FallbackPacket removeBoat;
+  public FallbackPacket teleportMinecart;
+  public FallbackPacket spawnBoatEntity;
+  public FallbackPacket spawnMinecartEntity;
+  public FallbackPacket setPassengers;
   public FallbackPacket[] xpCountdown;
 
+  public static int maxMovementTick, dynamicSpawnYPosition, maxTotalPacketsSent;
+
   @SuppressWarnings("ResultOfMethodCallIgnored")
   public void prepare() {
     // Preload the packet registry to avoid CPU/RAM issues on 1st connection
@@ -120,48 +116,51 @@ public class FallbackPreparer {
 
     // Prepare JoinGame packet
     joinGame = new FallbackPacketSnapshot(new JoinGamePacket(PLAYER_ENTITY_ID,
-      Sonar.get().getConfig().getVerification().getGamemode().getId(),
-      RANDOM.nextLong(), false, 0,
-      true, false, false,
-      new String[]{"minecraft:overworld"}, "minecraft:overworld"));
+      Sonar.get().getConfig().getVerification().getGamemode().getId(), RANDOM.nextLong(),
+      0, 0, false, true, false,
+      false, false, false, true,
+      new String[]{"minecraft:overworld"}, "minecraft:overworld", "flat"));
 
     // Prepare the gravity check
     maxMovementTick = Sonar.get().getConfig().getVerification().getGravity().getMaxMovementTicks();
-    maxFallDistance = 1;
 
-    double motionY = -0.08 * 0.98f;
+    double motionY = 0, fallDistance = 0;
+
     for (int i = 0; i < maxMovementTick; i++) {
-      motionY = (motionY - 0.08) * 0.98f;
-      maxFallDistance += Math.abs(motionY);
+      motionY = (motionY - 0.1) * 0.98f;
+      fallDistance += Math.abs(motionY);
     }
 
     // Set the dynamic block and collide Y position based on the maximum fall distance
-    dynamicSpawnYPosition = DEFAULT_Y_COLLIDE_POSITION + (int) Math.ceil(maxFallDistance);
+    dynamicSpawnYPosition = DEFAULT_Y_COLLIDE_POSITION + (int) Math.ceil(fallDistance);
     defaultSpawnPosition = new FallbackPacketSnapshot(new SetDefaultSpawnPositionPacket(
-      SPAWN_X_POSITION, dynamicSpawnYPosition, SPAWN_Z_POSITION));
+      SPAWN_X_POSITION, IN_AIR_Y_POSITION, SPAWN_Z_POSITION));
     spawnPosition = new FallbackPacketSnapshot(new SetPlayerPositionRotationPacket(
+      SPAWN_X_POSITION, IN_AIR_Y_POSITION, SPAWN_Z_POSITION,
+      0, 0, FIRST_TELEPORT_ID, 0, false));
+    fallStartPosition = new FallbackPacketSnapshot(new SetPlayerPositionRotationPacket(
+      SPAWN_X_POSITION, dynamicSpawnYPosition - IN_AIR_Y_POSITION, SPAWN_Z_POSITION,
+      0, -90, SECOND_TELEPORT_ID, 1 << 1, false));
+    fallStartPositionLegacy = new FallbackPacketSnapshot(new SetPlayerPositionRotationPacket(
       SPAWN_X_POSITION, dynamicSpawnYPosition, SPAWN_Z_POSITION,
-      0, -90, TELEPORT_ID, false));
+      0, -90, 0, 0, false));
 
     // Prepare collision platform positions
-    blockType = BlockType.valueOf(Sonar.get().getConfig().getGeneralConfig().getString(
-      "verification.checks.collision.collision-block-type").toUpperCase());
-    final BlockUpdate[] changedBlocks = new BlockUpdate[BLOCKS_PER_ROW * BLOCKS_PER_ROW];
+    final int length = BLOCKS_PER_ROW / 2;
+    for (int i = 0; i < BLOCKS_PACKETS.length; i++) {
+      final BlockUpdate[] blocks = new BlockUpdate[BLOCKS_PER_ROW * BLOCKS_PER_ROW];
 
-    int index = 0;
-    for (int x = 0; x < BLOCKS_PER_ROW; x++) {
-      for (int z = 0; z < BLOCKS_PER_ROW; z++) {
-        final BlockUpdate.BlockPosition position = new BlockUpdate.BlockPosition(
-          x + (BLOCKS_PER_ROW / 2),
-          DEFAULT_Y_COLLIDE_POSITION,
-          z + (BLOCKS_PER_ROW / 2),
-          0, 0);
-        changedBlocks[index++] = new BlockUpdate(position, blockType);
+      int index = 0;
+      for (int x = 0; x < BLOCKS_PER_ROW; x++) {
+        for (int z = 0; z < BLOCKS_PER_ROW; z++) {
+          final BlockUpdate.BlockPosition position = new BlockUpdate.BlockPosition(
+            x + length, DEFAULT_Y_COLLIDE_POSITION, z + length, 0, 0);
+          blocks[index++] = new BlockUpdate(position, POSSIBLE_BLOCK_TYPES[i]);
+        }
       }
+      BLOCKS_PACKETS[i] = new UpdateSectionBlocksPacket(0, 0, blocks);
     }
 
-    updateSectionBlocks = new FallbackPacketSnapshot(new UpdateSectionBlocksPacket(0, 0, changedBlocks));
-
     // Prepare disconnect packets during login
     blacklisted = new FallbackPacketSnapshot(DisconnectPacket.create(Sonar.get().getConfig().getVerification().getBlacklisted(), true));
     alreadyVerifying = new FallbackPacketSnapshot(DisconnectPacket.create(Sonar.get().getConfig().getVerification().getAlreadyVerifying(), true));
@@ -181,11 +180,27 @@ public class FallbackPreparer {
     }
 
     // Prepare packets for the vehicle check
-    removeEntities = new FallbackPacketSnapshot(new RemoveEntitiesPacket(VEHICLE_ENTITY_ID));
-    spawnEntity = new FallbackPacketSnapshot(new SpawnEntityPacket(
-      VEHICLE_ENTITY_ID, EntityType.BOAT, SPAWN_X_POSITION, IN_AIR_Y_POSITION, SPAWN_Z_POSITION));
+    removeBoat = new RemoveEntitiesPacket(VEHICLE_ENTITY_ID);
+    teleportMinecart = new TeleportEntityPacket(
+      VEHICLE_ENTITY_ID, SPAWN_X_POSITION, IN_VOID_Y_POSITION, SPAWN_Z_POSITION, false);
+    spawnBoatEntity = new FallbackPacketSnapshot(new SpawnEntityPacket(VEHICLE_ENTITY_ID,
+      EntityType.BOAT, RANDOM.nextInt(16), IN_AIR_Y_POSITION, RANDOM.nextInt(16),
+      0, 0, 0, 0));
+    spawnMinecartEntity = new FallbackPacketSnapshot(new SpawnEntityPacket(VEHICLE_ENTITY_ID,
+      EntityType.MINECART, RANDOM.nextInt(16), IN_AIR_Y_POSITION, RANDOM.nextInt(16),
+      0, 0, 0, 0));
     setPassengers = new FallbackPacketSnapshot(new SetPassengersPacket(VEHICLE_ENTITY_ID, PLAYER_ENTITY_ID));
 
+    // If the welcome message is empty, we don't need to send a message to the player
+    final String welcome = Sonar.get().getConfig().getMessagesConfig().getString("verification.welcome");
+    if (welcome.isEmpty()) {
+      welcomeMessage = null;
+    } else {
+      welcomeMessage = new FallbackPacketSnapshot(new SystemChatPacket(new ComponentHolder(
+        MiniMessage.miniMessage().deserialize(welcome,
+          Placeholder.component("prefix", Sonar.get().getConfig().getPrefix())))));
+    }
+
     if (Sonar.get().getConfig().getVerification().getMap().getTiming() != SonarConfiguration.Verification.Timing.NEVER
       || Sonar.get().getConfig().getVerification().getGravity().isCaptchaOnFail()) {
       // Prepare CAPTCHA messages
@@ -207,9 +222,13 @@ public class FallbackPreparer {
       }
 
       // Update the CAPTCHA generator if necessary
-      if (Sonar.get().getFallback().getCaptchaGenerator() == null
-        || Sonar.get().getFallback().getCaptchaGenerator() instanceof StandardCaptchaGenerator) {
-        Sonar.get().getFallback().setCaptchaGenerator(new StandardCaptchaGenerator(128, 128,
+      final CaptchaGenerationStartEvent generationStartEvent = new CaptchaGenerationStartEvent(
+        Sonar.get().getFallback().getCaptchaGenerator());
+      Sonar.get().getEventManager().publish(generationStartEvent);
+
+      if (generationStartEvent.getCaptchaGenerator() == null
+        || generationStartEvent.getCaptchaGenerator() instanceof StandardCaptchaGenerator) {
+        Sonar.get().getFallback().setCaptchaGenerator(new StandardCaptchaGenerator(
           Sonar.get().getConfig().getVerification().getMap().getBackgroundImage()));
       } else {
         Sonar.get().getLogger().info("Custom CAPTCHA generator detected, skipping reinitialization.");
@@ -224,5 +243,11 @@ public class FallbackPreparer {
       xpCountdown = null;
       Sonar.get().getFallback().setCaptchaGenerator(null);
     }
+
+    maxTotalPacketsSent = maxMovementTick + 2
+      + (xpCountdown == null ? 0 : xpCountdown.length) * 20 + 5
+      + Sonar.get().getConfig().getVerification().getVehicle().getMinimumPackets() * 4
+      + Sonar.get().getConfig().getVerification().getMap().getMaxTries()
+      + 150 /* some arbitrary leeway */;
   }
 }

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

@@ -0,0 +1,288 @@
+/*
+ * Copyright (C) 2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback.protocol.block;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+
+import java.util.function.Function;
+
+import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.*;
+
+// TODO: load mappings from a separate file
+@Getter
+@SuppressWarnings("unused")
+@RequiredArgsConstructor
+public enum BlockType {
+  // Useful resources:
+  // - https://github.com/PrismarineJS/minecraft-data/blob/master/data/pc/
+  // - https://pokechu22.github.io/Burger/
+  // - https://github.com/ViaVersion/Mappings/tree/main/mappings
+  //STONE(protocolVersion -> 1, 1),
+  ENCHANTMENT_TABLE(protocolVersion -> {
+    if (protocolVersion.compareTo(MINECRAFT_1_12_2) <= 0) {
+      return 116;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_1) <= 0) {
+      return 4612;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_2) <= 0) {
+      return 4613;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_15_2) <= 0) {
+      return 5116;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_1) <= 0) {
+      return 5132;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_4) <= 0) {
+      return 5136;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_18_2) <= 0) {
+      return 5333;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_1) <= 0) {
+      return 5719;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_3) <= 0) {
+      return 7159;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_4) <= 0) {
+      return 7385;
+    }
+    return 7389;
+  }, protocolVersion -> (double) 0.75f),
+  TRAPDOOR(protocolVersion -> {
+    // We have to use wooden trapdoors for 1.7 since 1.7 doesn't have iron trapdoors
+    if (protocolVersion.compareTo(MINECRAFT_1_7_6) <= 0) {
+      return 96;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_12_2) <= 0) {
+      return 167;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_1) <= 0) {
+      return 6509;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_2) <= 0) {
+      return 6510;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_15_2) <= 0) {
+      return 7016;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_1) <= 0) {
+      return 7552;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_4) <= 0) {
+      return 7556;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_18_2) <= 0) {
+      return 7802;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_1) <= 0) {
+      return 8293;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_3) <= 0) {
+      return 9937;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_4) <= 0) {
+      return 10269;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_20) <= 0) {
+      return 10273;
+    }
+    return 10414;
+  }, protocolVersion -> 0.1875),
+  END_PORTAL_FRAME(protocolVersion -> {
+    if (protocolVersion.compareTo(MINECRAFT_1_12_2) <= 0) {
+      return 120;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_1) <= 0) {
+      return 4633;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_2) <= 0) {
+      return 4634;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_15_2) <= 0) {
+      return 5137;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_1) <= 0) {
+      return 5153;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_4) <= 0) {
+      return 5157;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_18_2) <= 0) {
+      return 5358;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_1) <= 0) {
+      return 5744;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_3) <= 0) {
+      return 7184;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_4) <= 0) {
+      return 7410;
+    }
+    return 7414;
+  }, protocolVersion -> 0.8125),
+  DAYLIGHT_SENSOR(protocolVersion -> {
+    if (protocolVersion.compareTo(MINECRAFT_1_12_2) <= 0) {
+      return 151;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_1) <= 0) {
+      return 5651;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_2) <= 0) {
+      return 5652;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_15_2) <= 0) {
+      return 6158;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_1) <= 0) {
+      return 6694;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_4) <= 0) {
+      return 6698;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_18_2) <= 0) {
+      return 6916;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_1) <= 0) {
+      return 7327;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_3) <= 0) {
+      return 8811;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_4) <= 0) {
+      return 9063;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_20) <= 0) {
+      return 9067;
+    }
+    return 9207;
+  }, protocolVersion -> 0.375),
+  COBBLESTONE_WALL(protocolVersion -> {
+    if (protocolVersion.compareTo(MINECRAFT_1_12_2) <= 0) {
+      return 139;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_1) <= 0) {
+      return 5196;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_2) <= 0) {
+      return 5197;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_15_2) <= 0) {
+      return 5700;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_1) <= 0) {
+      return 5660;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_4) <= 0) {
+      return 5664;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_18_2) <= 0) {
+      return 5866;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_1) <= 0) {
+      return 6252;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_3) <= 0) {
+      return 7692;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_4) <= 0) {
+      return 7918;
+    }
+    return 7922;
+  }, protocolVersion -> 1.5),
+  STONE_SLABS(protocolVersion -> {
+    if (protocolVersion.compareTo(MINECRAFT_1_12_2) <= 0) {
+      return 44;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_1) <= 0) {
+      return 7296;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_2) <= 0) {
+      return 7297;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_15_2) <= 0) {
+      return 7809;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_1) <= 0) {
+      return 8345;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_4) <= 0) {
+      return 8349;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_18_2) <= 0) {
+      return 8595;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_1) <= 0) {
+      return 9092;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_3) <= 0) {
+      return 10748;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_4) <= 0) {
+      return 11086;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_20) <= 0) {
+      return 11090;
+    }
+    return 11231;
+  }, protocolVersion -> 0.5),
+  WHITE_CARPET(protocolVersion -> {
+    if (protocolVersion.compareTo(MINECRAFT_1_12_2) <= 0) {
+      return 171;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_1) <= 0) {
+      return 6823;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_2) <= 0) {
+      return 6824;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_15_2) <= 0) {
+      return 7330;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_1) <= 0) {
+      return 7866;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_4) <= 0) {
+      return 7870;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_18_2) <= 0) {
+      return 8116;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_1) <= 0) {
+      return 8607;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_3) <= 0) {
+      return 10251;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_4) <= 0) {
+      return 10583;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_20) <= 0) {
+      return 10587;
+    }
+    return 10728;
+  }, protocolVersion -> protocolVersion.compareTo(MINECRAFT_1_8) < 0 ? 0 : 0.0625);
+
+  private final Function<ProtocolVersion, Integer> id;
+  private final Function<ProtocolVersion, Double> blockHeight;
+}

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

@@ -25,12 +25,12 @@ import org.jetbrains.annotations.NotNull;
 @Getter
 public final class BlockUpdate {
   private final @NotNull BlockPosition position;
-  private final BlockType type;
+  private final BlockType blockType;
   private final int legacyBlockState, blockState;
 
-  public BlockUpdate(final @NotNull BlockPosition position, final BlockType type) {
+  public BlockUpdate(final @NotNull BlockPosition position, final BlockType blockType) {
     this.position = position;
-    this.type = type;
+    this.blockType = blockType;
     final int x = position.getX() - (position.getChunkX() << 4);
     final int y = position.getY();
     final int z = position.getZ() - (position.getChunkZ() << 4);

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/captcha/CaptchaPreparer.java

@@ -19,6 +19,7 @@ package xyz.jonesdev.sonar.common.fallback.protocol.captcha;
 
 import lombok.experimental.UtilityClass;
 import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.event.impl.CaptchaGenerationEndEvent;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
 
 import java.awt.image.BufferedImage;
@@ -65,6 +66,7 @@ public class CaptchaPreparer {
       }
 
       Sonar.get().getLogger().info("Finished preparing {} CAPTCHA answers ({}s)!", preparedAmount, timer);
+      Sonar.get().getEventManager().publish(new CaptchaGenerationEndEvent(timer, preparedAmount));
     });
   }
 

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/captcha/ItemType.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2024 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback.protocol.captcha;
+
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+
+import java.util.function.Function;
+
+import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.*;
+
+// TODO: load mappings from a separate file
+@RequiredArgsConstructor
+public enum ItemType {
+  // Useful resources:
+  // - https://github.com/PrismarineJS/minecraft-data/blob/master/data/pc/
+  // - https://pokechu22.github.io/Burger/1.20.4.html
+  // - https://github.com/ViaVersion/Mappings/tree/main/mappings
+  FILLED_MAP(protocolVersion -> {
+    if (protocolVersion.compareTo(MINECRAFT_1_12_2) <= 0) {
+      return 358;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_1) <= 0) {
+      return 608;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_13_2) <= 0) {
+      return 613;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_15_2) <= 0) {
+      return 671;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_16_4) <= 0) {
+      return 733;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_18_2) <= 0) {
+      return 847;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_1) <= 0) {
+      return 886;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_3) <= 0) {
+      return 914;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_19_4) <= 0) {
+      return 937;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_20_2) <= 0) {
+      return 941;
+    }
+    if (protocolVersion.compareTo(MINECRAFT_1_20_3) <= 0) {
+      return 979;
+    }
+    return 982;
+  });
+
+  private final Function<ProtocolVersion, Integer> idFunction;
+
+  public int getId(final @NotNull ProtocolVersion protocolVersion) {
+    return idFunction.apply(protocolVersion);
+  }
+}

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/captcha/MapColorPalette.java

@@ -204,16 +204,21 @@ public class MapColorPalette {
         closestIndex = index;
       }
     }
+    // Fix transparent colors by setting them to white
+    // TODO: implement better color tables (mappings?)
+    if (closestIndex > -1 && closestIndex < 3) {
+      closestIndex = 34;
+    }
     return closestIndex;
   }
 
-  private int calculateColorDistance(final int argb0, final int argb1) {
-    final int red0 = (argb0 >> 16) & 0xFF;
-    final int green0 = (argb0 >> 8) & 0xFF;
-    final int blue0 = argb0 & 0xFF;
-    final int red1 = (argb1 >> 16) & 0xFF;
-    final int green1 = (argb1 >> 8) & 0xFF;
-    final int blue1 = argb1 & 0xFF;
+  private int calculateColorDistance(final int rgb0, final int rgb1) {
+    final int red0 = (rgb0 >> 16) & 0xFF;
+    final int green0 = (rgb0 >> 8) & 0xFF;
+    final int blue0 = rgb0 & 0xFF;
+    final int red1 = (rgb1 >> 16) & 0xFF;
+    final int green1 = (rgb1 >> 8) & 0xFF;
+    final int blue1 = rgb1 & 0xFF;
     // Color distance metric (e.g. squared Euclidean distance)
     return (red0 - red1) * (red0 - red1)
       + (green0 - green1) * (green0 - green1)