Release 2.1.8 (#385 )

Remove initial "unofficial branch" warning
Make the update checker more accessible to users
2026-11-05 17:22:34 -05:00 · 2024-09-22 13:21:19 +02:00 · 2024-09-22 13:00:11 +02:00 · 2024-09-22 12:54:31 +02:00 · 2024-09-21 18:22:56 +02:00 · 2024-09-21 14:41:59 +02:00
224 changed files with 2033 additions and 2102 deletions
@@ -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}]
@@ -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
@@ -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
@@ -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
@@ -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;
@@ -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);
-  }
 }
@@ -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);
  }
 }
@@ -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);
 }
@@ -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;
+}
@@ -0,0 +1,31 @@
+/*
+ * 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.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+import xyz.jonesdev.sonar.api.event.SonarEvent;
+import xyz.jonesdev.sonar.api.fallback.captcha.CaptchaGenerator;
+
+@Getter
+@Setter
+@AllArgsConstructor
+public final class CaptchaGenerationStartEvent implements SonarEvent {
+  private CaptchaGenerator captchaGenerator;
+}
@@ -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;
 }
@@ -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;

@@ -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();
+      }
+    });
  }
 }
@@ -26,7 +26,6 @@ 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
@@ -45,15 +44,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,14 +63,6 @@ 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
   *
@@ -97,16 +87,4 @@ public interface FallbackUser {
      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);
 }
@@ -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);
 }
@@ -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);
+  }
+}
@@ -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())),
@@ -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())),
@@ -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();
+}
@@ -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;
+  }
 }
@@ -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)
  }
@@ -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
  }
 }

@@ -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) {
@@ -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',
@@ -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();
@@ -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);
  }
 }
@@ -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();
  }
 }
@@ -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
@@ -67,9 +64,7 @@ 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);
  }

@@ -92,62 +87,61 @@ public abstract class FallbackInboundHandlerAdapter extends ChannelInboundHandle
    }
    // Connections from unknown protocol versions will be discarded
    // 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();
+    channel.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())) {
+    if (Sonar.get().getFallback().getConnected().containsKey(inetAddress)) {
      customDisconnect(channel, protocolVersion, alreadyVerifying);
      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())) {
+    if (Sonar.get().getConfig().getVerification().getBlacklistedProtocols().contains(protocolVersion.getProtocol())) {
      customDisconnect(channel, protocolVersion, protocolBlacklisted);
      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(channel, protocolVersion, blacklisted);
+        return;
+      }
    }

    // Don't continue the verification process if the verification is disabled
    if (!Sonar.get().getFallback().shouldVerifyNewPlayers()) {
-      initialLogin(ctx, inboundHandler.getInetAddress(), loginPacket);
+      initialLogin(ctx, inetAddress, loginPacket);
      return;
    }

    // Completely skip Geyser connections if configured
    final boolean geyser = GeyserUtil.isGeyserConnection(channel, socketAddress);
    if (geyser && !Sonar.get().getConfig().getVerification().isCheckGeyser()) {
-      initialLogin(ctx, inboundHandler.getInetAddress(), loginPacket);
+      initialLogin(ctx, inetAddress, loginPacket);
      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, inetAddress, loginPacket);
      return;
    }

    // Check if the IP address is currently being rate-limited
-    if (!Sonar.get().getFallback().getRatelimiter().attempt(inboundHandler.getInetAddress())) {
+    if (!Sonar.get().getFallback().getRatelimiter().attempt(inetAddress)) {
      customDisconnect(channel, protocolVersion, reconnectedTooFast);
      return;
    }
@@ -156,9 +150,9 @@ 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, (__, action) -> {
      // Check if the player is already queued since we don't want bots to flood the queue
-      if (runnable != null) {
+      if (action != null) {
        customDisconnect(channel, protocolVersion, alreadyQueued);
        // Remove other instances of this IP address from the queue
        return null;
@@ -167,17 +161,13 @@ 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()) {
+        if (!Sonar.get().getConfig().getVerification().getValidNameRegex().matcher(username).matches()) {
          customDisconnect(channel, protocolVersion, invalidUsername);
          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(channel, inetAddress, protocolVersion, username, fingerprint, geyser);
      };
    });
  }
@@ -216,23 +206,23 @@ public abstract class FallbackInboundHandlerAdapter extends ChannelInboundHandle
  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;
+    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(ctx.channel(), protocolVersion, tooManyOnlinePerIP);
+          return count + 1;
+        }
      }
-    }

-    // Let the server know about the login packet
-    loginPacket.run();
+      // 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;
+    });
  }

  /**
@@ -18,7 +18,6 @@
 package xyz.jonesdev.sonar.common.fallback;

 import io.netty.channel.Channel;
-import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelPipeline;
 import lombok.Getter;
 import lombok.Setter;
@@ -26,8 +25,6 @@ import lombok.ToString;
 import net.kyori.adventure.text.Component;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.event.impl.UserBlacklistedEvent;
-import xyz.jonesdev.sonar.api.event.impl.UserVerifyFailedEvent;
 import xyz.jonesdev.sonar.api.event.impl.UserVerifyJoinEvent;
 import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
@@ -37,20 +34,18 @@ 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.FallbackPreparer;
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.DisconnectPacket;
-import xyz.jonesdev.sonar.common.fallback.session.FallbackLoginSessionHandler;
+import xyz.jonesdev.sonar.common.fallback.verification.FallbackPreJoinHandler;
 import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
-import xyz.jonesdev.sonar.common.util.exception.QuietDecoderException;

 import java.net.InetAddress;
-import java.util.UUID;
-import java.util.concurrent.TimeUnit;

 import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.*;
-import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.*;
+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"})
@@ -59,36 +54,28 @@ public final class FallbackUserWrapper implements FallbackUser {
  private final ChannelPipeline pipeline;
  private final InetAddress inetAddress;
  private final ProtocolVersion protocolVersion;
-  private final UUID offlineUuid;
-  @Setter
-  private boolean receivedClientSettings;
-  @Setter
-  private boolean receivedPluginMessage;
+  private final String fingerprint;
+  private final String username;
  private final boolean geyser;
-  private final SystemTimer loginTimer = new SystemTimer();
+  private final SystemTimer loginTimer;
+  @Setter
+  private boolean forceCaptcha;

  public FallbackUserWrapper(final @NotNull Channel channel,
                             final @NotNull InetAddress inetAddress,
                             final @NotNull ProtocolVersion protocolVersion,
-                             final @NotNull UUID offlineUuid,
+                             final @NotNull String username,
+                             final @NotNull String fingerprint,
                             final boolean geyser) {
    this.channel = channel;
    this.pipeline = channel.pipeline();
    this.inetAddress = inetAddress;
    this.protocolVersion = protocolVersion;
-    this.offlineUuid = offlineUuid;
+    this.username = username;
+    this.fingerprint = fingerprint;
    this.geyser = geyser;
-  }
+    this.loginTimer = new SystemTimer();

-  @Override
-  public void disconnect(final @NotNull Component reason) {
-    final FallbackPacketEncoder encoder = pipeline.get(FallbackPacketEncoder.class);
-    final boolean duringLogin = encoder != null && encoder.getPacketRegistry() != GAME;
-    closeWith(channel, protocolVersion, DisconnectPacket.create(reason, duringLogin));
-  }
-
-  @Override
-  public void hijack(final @NotNull String username, final @NotNull UUID offlineUuid) {
    GlobalSonarStatistics.totalAttemptedVerifications++;

    if (Sonar.get().getConfig().getVerification().isLogConnections()
@@ -112,7 +99,7 @@ public final class FallbackUserWrapper implements FallbackUser {
      }

      // Mark the player as connected by caching them in a map of verifying players
-      Sonar.get().getFallback().getConnected().compute(inetAddress, (_k, _v) -> (byte) 0);
+      Sonar.get().getFallback().getConnected().compute(inetAddress, (__, v) -> true);

      // Replace normal encoder to allow custom packets
      final FallbackPacketEncoder newEncoder = new FallbackPacketEncoder(protocolVersion);
@@ -120,17 +107,17 @@ public final class FallbackUserWrapper implements FallbackUser {
      pipeline.addLast(FALLBACK_PACKET_ENCODER, newEncoder);

      // Send LoginSuccess packet to make the client think they are joining the server
-      write(FallbackPreparer.loginSuccess);
+      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 fallbackPacketDecoder = new FallbackPacketDecoder(protocolVersion);
+      final FallbackPacketDecoder newDecoder = new FallbackPacketDecoder(protocolVersion);
      pipeline.addFirst(FALLBACK_FRAME_DECODER, new FallbackVarInt21FrameDecoder());
-      pipeline.addLast(FALLBACK_PACKET_DECODER, fallbackPacketDecoder);
+      pipeline.addLast(FALLBACK_PACKET_DECODER, newDecoder);
      // Listen for all incoming packets by setting the packet listener
-      fallbackPacketDecoder.setListener(new FallbackLoginSessionHandler(this, username));
+      newDecoder.setListener(new FallbackPreJoinHandler(this));

      // Make sure to catch all exceptions during the verification
      pipeline.addLast(FALLBACK_TAIL_EXCEPTIONS, FallbackTailExceptionsHandler.INSTANCE);
@@ -138,76 +125,9 @@ public final class FallbackUserWrapper implements FallbackUser {
  }

  @Override
-  public void fail(final @NotNull String reason) {
-    GlobalSonarStatistics.totalFailedVerifications++;
-
-    disconnect(Sonar.get().getConfig().getVerification().getVerificationFailed());
-
-    final boolean shouldLog = Sonar.get().getAttackTracker().getCurrentAttack() == null
-      || Sonar.get().getConfig().getVerification().isLogDuringAttack();
-
-    if (shouldLog) {
-      Sonar.get().getLogger().info(
-        Sonar.get().getConfig().getMessagesConfig().getString("verification.logs.failed")
-          .replace("<ip>", Sonar.get().getConfig().formatAddress(getInetAddress()))
-          .replace("<protocol>", String.valueOf(getProtocolVersion().getProtocol()))
-          .replace("<reason>", reason));
-    }
-
-    // Call the VerifyFailedEvent for external API usage
-    Sonar.get().getEventManager().publish(new UserVerifyFailedEvent(this, reason));
-
-    // Use a label, so we can easily add more code beneath this method in the future
-    blacklist: {
-      // Check if the player has too many failed attempts
-      final int limit = Sonar.get().getConfig().getVerification().getBlacklistThreshold();
-      // The user is allowed to disable the blacklist entirely by setting the threshold to 0
-      if (limit <= 0) break blacklist;
-
-      final String hostAddress = inetAddress.getHostAddress();
-      final int score = Sonar.get().getFallback().getBlacklist().get(hostAddress, __ -> 0);
-      final int newScore = score + 1;
-
-      Sonar.get().getFallback().getBlacklist().put(hostAddress, newScore);
-
-      // The player hasn't been blacklisted yet, so skip this iteration
-      if (newScore < limit) break blacklist;
-
-      GlobalSonarStatistics.totalBlacklistedPlayers++;
-
-      // Call the BotBlacklistedEvent for external API usage
-      Sonar.get().getEventManager().publish(new UserBlacklistedEvent(this));
-
-      if (shouldLog) {
-        Sonar.get().getLogger().info(
-          Sonar.get().getConfig().getMessagesConfig().getString("verification.logs.blacklisted")
-            .replace("<ip>", Sonar.get().getConfig().formatAddress(getInetAddress()))
-            .replace("<protocol>", String.valueOf(getProtocolVersion().getProtocol())));
-      }
-    }
-
-    // Throw an exception to avoid further code execution
-    throw QuietDecoderException.INSTANCE;
-  }
-
-  /**
-   * @param channel         Channel to close
-   * @param protocolVersion Protocol version
-   * @param msg             Packet to close the channel with
-   */
-  public static void closeWith(final @NotNull Channel channel,
-                               final @NotNull ProtocolVersion protocolVersion,
-                               final @NotNull Object msg) {
-    if (protocolVersion.compareTo(MINECRAFT_1_8) < 0
-      && protocolVersion.compareTo(MINECRAFT_1_7_2) >= 0) {
-      channel.eventLoop().execute(() -> {
-        channel.config().setAutoRead(false);
-        channel.eventLoop().schedule(() -> {
-          channel.writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
-        }, 250L, TimeUnit.MILLISECONDS);
-      });
-    } else {
-      channel.writeAndFlush(msg).addListener(ChannelFutureListener.CLOSE);
-    }
+  public void disconnect(final @NotNull Component reason) {
+    final FallbackPacketEncoder encoder = pipeline.get(FallbackPacketEncoder.class);
+    final boolean duringLogin = encoder != null && encoder.getPacketRegistry() != GAME;
+    closeWith(channel, protocolVersion, DisconnectPacket.create(reason, duringLogin));
  }
 }
@@ -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;
    }
  }
 }
@@ -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);
  }
@@ -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),
@@ -214,19 +217,19 @@ public enum FallbackPacketRegistry {
        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, false),
-        map(0x2B, MINECRAFT_1_13, false),
-        map(0x2C, MINECRAFT_1_14, false),
-        map(0x2D, MINECRAFT_1_15, false),
-        map(0x2C, MINECRAFT_1_16, false),
-        map(0x2B, MINECRAFT_1_16_2, false),
-        map(0x2C, MINECRAFT_1_17, false),
-        map(0x29, MINECRAFT_1_19, false),
-        map(0x2B, MINECRAFT_1_19_1, false),
-        map(0x2A, MINECRAFT_1_19_3, false),
-        map(0x2E, MINECRAFT_1_19_4, false),
-        map(0x2F, MINECRAFT_1_20_2, false),
-        map(0x31, MINECRAFT_1_20_5, false));
+        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),
@@ -320,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));
@@ -363,6 +366,25 @@ public enum FallbackPacketRegistry {
        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),
@@ -584,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.");
      }
@@ -617,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");
          }

@@ -641,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)
@@ -663,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);
  }
 }
@@ -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(50);
+  public static final int VEHICLE_BOAT_ENTITY_ID = PLAYER_ENTITY_ID + 1 + RANDOM.nextInt(10);
+  public static final int VEHICLE_MINECART_ENTITY_ID = VEHICLE_BOAT_ENTITY_ID + 1 + RANDOM.nextInt(10);
+
+  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 enterCodeMessage;
  public FallbackPacket incorrectCaptcha;
-  // JoinGame
-  public static final int PLAYER_ENTITY_ID = RANDOM.nextInt(50);
-  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,36 +95,16 @@ public class FallbackPreparer {
  public FallbackPacket protocolBlacklisted;
  public FallbackPacket invalidUsername;
  public FallbackPacket tooManyOnlinePerIP;
-
-  // Vehicle
-  public FallbackPacket removeBoatEntities;
-  public FallbackPacket removeMinecartEntities;
+  public FallbackPacket removeBoat;
+  public FallbackPacket teleportMinecart;
  public FallbackPacket spawnBoatEntity;
  public FallbackPacket spawnMinecartEntity;
  public FallbackPacket setBoatPassengers;
  public FallbackPacket setMinecartPassengers;
-  public final int VEHICLE_BOAT_ENTITY_ID = PLAYER_ENTITY_ID + 1 + RANDOM.nextInt(10);
-  public final int VEHICLE_MINECART_ENTITY_ID = VEHICLE_BOAT_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[] xpCountdown;

+  public static int maxMovementTick, dynamicSpawnYPosition, maxTotalPacketsSent;
+
  @SuppressWarnings("ResultOfMethodCallIgnored")
  public void prepare() {
    // Preload the packet registry to avoid CPU/RAM issues on 1st connection
@@ -124,48 +117,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));
@@ -185,12 +181,15 @@ public class FallbackPreparer {
    }

    // Prepare packets for the vehicle check
-    removeBoatEntities = new FallbackPacketSnapshot(new RemoveEntitiesPacket(VEHICLE_BOAT_ENTITY_ID));
-    removeMinecartEntities = new FallbackPacketSnapshot(new RemoveEntitiesPacket(VEHICLE_MINECART_ENTITY_ID));
-    spawnBoatEntity = new FallbackPacketSnapshot(new SpawnEntityPacket(
-      VEHICLE_BOAT_ENTITY_ID, EntityType.BOAT, SPAWN_X_POSITION, IN_AIR_Y_POSITION, SPAWN_Z_POSITION));
-    spawnMinecartEntity = new FallbackPacketSnapshot(new SpawnEntityPacket(
-      VEHICLE_MINECART_ENTITY_ID, EntityType.MINECART, SPAWN_X_POSITION, IN_AIR_Y_POSITION, SPAWN_Z_POSITION));
+    removeBoat = new RemoveEntitiesPacket(VEHICLE_BOAT_ENTITY_ID);
+    teleportMinecart = new TeleportEntityPacket(
+      VEHICLE_MINECART_ENTITY_ID, SPAWN_X_POSITION, IN_VOID_Y_POSITION, SPAWN_Z_POSITION, false);
+    spawnBoatEntity = new FallbackPacketSnapshot(new SpawnEntityPacket(VEHICLE_BOAT_ENTITY_ID,
+      EntityType.BOAT, RANDOM.nextInt(16), IN_AIR_Y_POSITION, RANDOM.nextInt(16),
+      0, 0, 0, 0));
+    spawnMinecartEntity = new FallbackPacketSnapshot(new SpawnEntityPacket(VEHICLE_MINECART_ENTITY_ID,
+      EntityType.MINECART, RANDOM.nextInt(16), IN_AIR_Y_POSITION, RANDOM.nextInt(16),
+      0, 0, 0, 0));
    setBoatPassengers = new FallbackPacketSnapshot(new SetPassengersPacket(VEHICLE_BOAT_ENTITY_ID, PLAYER_ENTITY_ID));
    setMinecartPassengers = new FallbackPacketSnapshot(new SetPassengersPacket(VEHICLE_MINECART_ENTITY_ID, PLAYER_ENTITY_ID));

@@ -215,9 +214,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.");
@@ -232,5 +235,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 */;
  }
 }
@@ -0,0 +1,293 @@
+/*
+ * 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 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
+@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;
+  }, 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;
+  }, 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;
+  }, 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;
+  }, 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;
+  }, 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;
+  }, 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;
+  }, 0.0625);
+
+  private final Function<ProtocolVersion, Integer> idFunction;
+  @Getter
+  private final double blockHeight;
+
+  public int getId(final @NotNull ProtocolVersion protocolVersion) {
+    return idFunction.apply(protocolVersion);
+  }
+}
@@ -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);
@@ -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));
    });
  }

@@ -23,7 +23,9 @@ import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;

 import java.util.function.Function;

-@SuppressWarnings("unused")
+import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.*;
+
+// TODO: load mappings from a separate file
@RequiredArgsConstructor
 public enum ItemType {
  // Useful resources:
@@ -31,62 +33,40 @@ public enum ItemType {
  // - https://pokechu22.github.io/Burger/1.20.4.html
  // - https://github.com/ViaVersion/Mappings/tree/main/mappings
  FILLED_MAP(protocolVersion -> {
-    switch (protocolVersion) {
-      // 1.13-1.13.1
-      case MINECRAFT_1_13:
-      case MINECRAFT_1_13_1:
-        return 608;
-      // 1.13.2
-      case MINECRAFT_1_13_2:
-        return 613;
-      // 1.14-1.15.2
-      case MINECRAFT_1_14:
-      case MINECRAFT_1_14_1:
-      case MINECRAFT_1_14_2:
-      case MINECRAFT_1_14_3:
-      case MINECRAFT_1_14_4:
-      case MINECRAFT_1_15:
-      case MINECRAFT_1_15_1:
-      case MINECRAFT_1_15_2:
-        return 671;
-      // 1.16-1.16.4
-      case MINECRAFT_1_16:
-      case MINECRAFT_1_16_1:
-      case MINECRAFT_1_16_2:
-      case MINECRAFT_1_16_3:
-      case MINECRAFT_1_16_4:
-        return 733;
-      // 1.17-1.18.2
-      case MINECRAFT_1_17:
-      case MINECRAFT_1_17_1:
-      case MINECRAFT_1_18:
-      case MINECRAFT_1_18_2:
-        return 847;
-      // 1.19-1.19.1
-      case MINECRAFT_1_19:
-      case MINECRAFT_1_19_1:
-        return 886;
-      // 1.19.3
-      case MINECRAFT_1_19_3:
-        return 914;
-      // 1.19.4
-      case MINECRAFT_1_19_4:
-        return 937;
-      // 1.20-1.20.2
-      case MINECRAFT_1_20:
-      case MINECRAFT_1_20_2:
-        return 941;
-      // 1.20.3
-      case MINECRAFT_1_20_3:
-        return 979;
-      // 1.20.5-1.21
-      case MINECRAFT_1_20_5:
-      case MINECRAFT_1_21:
-        return 982;
-      default:
-        // 1.7-1.12.2
-        return 358;
+    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;
Author	SHA1	Message	Date
Jones	fc9c1026b1	Release 2.1.8 (#385 )	2024-09-22 13:21:19 +02:00
Jones	aae49aeb63	Remove initial "unofficial branch" warning	2024-09-22 13:00:11 +02:00
Jones	f7a6f04792	Make the update checker more accessible to users	2024-09-22 12:54:31 +02:00
Jones	e36ba9840c	Hide secure-chat toast from 1.20.5+ clients	2024-09-21 18:22:56 +02:00
Jones	40bceb71f1	Use the modern way of registering Velocity commands	2024-09-21 14:41:59 +02:00
Jones	2d3bf91444	Recode bandwidth statistic handling	2024-09-21 14:37:58 +02:00
Jones	45ab258a6f	Fix upload-artifacts unable to find artifacts	2024-09-21 14:07:54 +02:00
Jones	600277660c	General project base refactoring	2024-09-21 14:05:54 +02:00
MISHAandJones	6918afae52	JAR Downloads via GitHub Actions (#384 ) * Update gradle.yml * Update gradle.yml * fix: smaller improvements to CI * fix: wildcard pattern breaking CI * fix(ci): revert wildcard patterns --------- Co-authored-by: Jones <admin@jonesdev.xyz>	2024-09-21 13:45:15 +02:00
Jones	07cfc4ad1c	Randomize X and Z positions in vehicle check	2024-09-19 17:30:06 +02:00
Jones	65eb9a503f	Fix potential issue in the vehicle handler	2024-09-19 17:15:47 +02:00
Jones	f5d7cc1511	Small collision check improvements	2024-09-19 16:59:25 +02:00
Jones	2cb0a48657	Add some more smaller movement validations	2024-09-19 16:45:39 +02:00
Jones	646f296039	Don't notify the channel about unhandled packets	2024-09-19 16:29:16 +02:00
Jones	a698c26d39	Fix the 1.7.2-1.7.10 minimum Y coordinate issue	2024-09-19 16:21:19 +02:00
Jones	25136d6332	Small micro-optimizations in the packet registry	2024-09-19 13:11:20 +02:00
Jones	ee4b1ffef4	Optimize processing of queued logins	2024-09-18 13:11:59 +02:00
Jones	fe145836fe	Use a better-suited data type for connected players	2024-09-18 12:34:34 +02:00
Jones	47100f4071	Bump Gradle from 8.10 to 8.10.1	2024-09-18 10:52:03 +02:00
Jones	57311996c8	Set Gradle groupId to `xyz.jonesdev`	2024-09-18 10:49:01 +02:00
Jones	7ad8e48431	Bump bungeecord-proxy from master-SNAPSHOT to 1.21-SNAPSHOT	2024-09-18 10:39:55 +02:00
Jones	154d999b88	Bump velocity-proxy from 3.3.0-SNAPSHOT to 3.4.0-SNAPSHOT	2024-09-18 10:39:04 +02:00
Jones	bde637c9c5	Exempt Bedrock players from packet order checks	2024-09-18 10:07:56 +02:00
Jones	cb1c62f478	Fix max total packets false positive on 1.7-1.8	2024-09-17 15:20:17 +02:00
Jones	3727742419	Add CaptchaGenerationStartEvent, CaptchaGenerationEndEvent	2024-09-17 14:52:15 +02:00
Jones	f79bb38740	Remove a debug message	2024-09-17 14:48:47 +02:00
Jones	7d60ba85e7	Fix custom CAPTCHA background image not working	2024-09-17 14:44:31 +02:00
Jones	cec7fa07c2	Fix another potential false positive with Geyser	2024-09-17 13:12:57 +02:00
Jones	2be2380e3f	Fix invalid login mappings for 1.18-1.18.1	2024-09-16 14:18:08 +02:00
dependabot[bot]	ae99ade03a	Bump com.gradleup.shadow from 8.3.0 to 8.3.1 (#382 ) Bumps [com.gradleup.shadow](https://github.com/GradleUp/shadow) from 8.3.0 to 8.3.1. - [Release notes](https://github.com/GradleUp/shadow/releases) - [Commits](https://github.com/GradleUp/shadow/compare/8.3.0...8.3.1) --- 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>	2024-09-16 13:53:09 +02:00
Jones	59731a93f1	Release 2.1.7 (#381 )	2024-09-15 14:09:43 +02:00
Jones	ace55fbe7b	Fix a small compilation error	2024-09-15 14:08:18 +02:00
Jones	696d3c5c81	Fix some Bedrock false positives	2024-09-15 14:03:00 +02:00
Jones	a1e4ea3f5b	Fix exception while serializing JsonArray (https://github.com/PaperMC/Velocity/pull/1426 )	2024-09-14 15:45:19 +02:00
Jones	6b054bd56c	Fix invalid block mappings for 1.14-1.14.3	2024-09-14 10:35:51 +02:00
Jones	c8e2142dd9	Cap username length in LoginSuccess (clientbound)	2024-09-12 18:20:11 +02:00
Jones	1cf7ef6994	Add invalid window ID check to transactions	2024-09-11 21:14:08 +02:00
Jones	af8aa103bf	Randomize some more position-related values	2024-09-11 19:31:31 +02:00
Jones	d1f2c15a8f	Fix a false positive with the moved too far check	2024-09-11 19:28:29 +02:00
Jones	5a68c4d557	Added another vehicle Y position check	2024-09-11 19:23:58 +02:00