Address code review concerns

# Conflicts:
#	common/src/main/java/ac/grim/grimac/utils/data/ReachInterpolationData.java

.deepsource.toml

@@ -5,4 +5,4 @@ name = "java"
 enabled = true
 
   [analyzers.meta]
-  runtime_version = "16"
+  runtime_version = "17"

.editorconfig

@@ -0,0 +1,19 @@
+root = true
+
+[*]
+charset = utf-8
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+max_line_length = 100
+tab_width = 4
+end_of_line = crlf
+trim_trailing_whitespace = true
+
+# intellij specific configuration
+ij_continuation_indent_size = 8
+ij_formatter_off_tag = @formatter:off
+ij_formatter_on_tag = @formatter:on
+ij_formatter_tags_enabled = false
+ij_smart_tabs = false
+ij_wrap_on_typing = false

.github/ISSUE_TEMPLATE/bypass.yml

@@ -30,11 +30,19 @@ body:
     validations:
       required: true
 
+  - type: input
+    attributes:
+        label: Client version
+        description: |
+            Provide the version of your Minecraft client.
+    validations:
+        required: true
+
   - type: textarea
     attributes:
       label: Plugins
       description: |
-        List all plugins running on your server. To list plugins, run `/plugins`.
+        List all plugins or mods running on your server. To list plugins on bukkit, run `/plugins`.
         If your server is behind a proxy such as Bungeecord, you should list the proxy's plugins as well.
     validations:
-      required: true
+      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/crash-or-error.yml

@@ -39,11 +39,23 @@ body:
     validations:
       required: true
 
+  - type: dropdown
+    id: type
+    attributes:
+        label: Affected Platform(s)
+        description: Which platforms does this issue affect? If you aren't sure, select both.
+        options:
+            - "Bukkit"
+            - "Fabric"
+        multiple: true
+    validations:
+        required: true
+
   - type: textarea
     attributes:
-      label: Plugins
+      label: Plugins/mods
       description: |
-        List all plugins running on your server. To list plugins, run `/plugins`.
+        List all plugins or mods running on your server. To list plugins on bukkit, run `/plugins`.
         If your server is behind a proxy such as Bungeecord, you should list the proxy's plugins as well.
     validations:
-      required: true
+      required: true

.github/ISSUE_TEMPLATE/false-positive.yml

@@ -46,7 +46,7 @@ body:
     attributes:
       label: Plugins
       description: |
-        List all plugins running on your server. To list plugins, run `/plugins`.
+        List all plugins or mods running on your server. To list plugins on bukkit, run `/plugins`.
         If your server is behind a proxy such as Bungeecord, you should list the proxy's plugins as well.
     validations:
-      required: true
+      required: true

.github/ISSUE_TEMPLATE/other-issues.yml

@@ -1,5 +1,5 @@
-name: Plugin incompatibility or other bug
-description: Report a bug or plugin incompatibility here
+name: Plugin/mod incompatibility or other bug
+description: Report a bug or plugin/mod incompatibility here
 labels: ["bug"]
 body:
   - type: textarea
@@ -30,11 +30,23 @@ body:
     validations:
       required: true
 
+  - type: dropdown
+    id: type
+    attributes:
+        label: Affected Platform(s)
+        description: Which platforms does this issue affect? If you aren't sure, select both.
+        options:
+            - "Bukkit"
+            - "Fabric"
+        multiple: true
+    validations:
+        required: true
+
   - type: textarea
     attributes:
       label: Plugins
       description: |
-        List all plugins running on your server. To list plugins, run `/plugins`.
+        List all plugins or mods running on your server. To list plugins on bukkit, run `/plugins`.
         If your server is behind a proxy such as Bungeecord, you should list the proxy's plugins as well.
     validations:
-      required: true
+      required: true

.github/ISSUE_TEMPLATE/simulation-false-positive.yml

@@ -45,7 +45,7 @@ body:
     attributes:
       label: Plugins
       description: |
-        List all plugins running on your server. To list plugins, run `/plugins`.
+        List all plugins or mods running on your server. To list plugins on bukkit, run `/plugins`.
         If your server is behind a proxy such as Bungeecord, you should list the proxy's plugins as well.
     validations:
-      required: true
+        required: true

.github/workflows/build-and-publish.yml

@@ -0,0 +1,229 @@
+name: Reusable Build and Publish
+
+on:
+    workflow_call:
+        inputs:
+            is-release-build:
+                description: 'True if this is a release build, which affects versioning and publishing.'
+                required: true
+                type: boolean
+            release-version-type:
+                description: 'The version type for Modrinth (e.g., release, beta, alpha).'
+                required: true
+                type: string
+            release-changelog:
+                description: 'The changelog content for the release.'
+                required: false
+                type: string
+                default: ''
+            run-build-scan:
+                description: 'Whether to enable Develocity build scan'
+                required: true
+                type: boolean
+            publish-artifacts:
+                description: 'If true, uploads artifacts to Modrinth and other distribution sites.'
+                required: true
+                type: boolean
+        secrets:
+            MODRINTH_ID:
+                required: false
+            MODRINTH_TOKEN:
+                required: false
+            BUILD_UPDATE_TOKEN:
+                required: true
+            BUILD_UPDATE_URL:
+                required: true
+
+jobs:
+    build:
+        runs-on: ubuntu-latest
+        permissions:
+            contents: read
+            packages: write
+
+        env:
+            MODRINTH_ID: ${{ secrets.MODRINTH_ID }}
+            MODRINTH_TOKEN: ${{ secrets.MODRINTH_TOKEN }}
+            GRIM_MAIN_BRANCH: ${{ github.event.repository.default_branch }}
+            BUILD_UPDATE_TOKEN: ${{ secrets.BUILD_UPDATE_TOKEN }}
+
+        steps:
+            - name: Checkout repository with full history
+              uses: actions/checkout@v4
+              with:
+                  persist-credentials: false
+                  fetch-depth: 200
+
+            - name: Set up JDK 21
+              uses: actions/setup-java@v4
+              with:
+                  java-version: '21'
+                  distribution: 'temurin'
+                  server-id: github
+                  settings-path: ${{ github.workspace }}
+
+            - name: Setup Gradle
+              uses: gradle/actions/setup-gradle@v3
+              with:
+                  cache-read-only: ${{ github.ref_name != github.event.repository.default_branch && github.ref_name != 'dev' }}
+
+            - name: Cache Gradle Loom Cache
+              uses: actions/cache@v4
+              with:
+                  path: .gradle/loom-cache
+                  key: loom-cache-${{ runner.os }}-${{ hashFiles('**/libs.versions.toml', 'fabric/**/build.gradle.kts') }}
+                  restore-keys: |
+                      loom-cache-${{ runner.os }}
+
+            - name: Set Git Environment Variables
+              run: |
+                  echo "GRIM_GIT_REPO=${{ github.event.repository.name }}" >> $GITHUB_ENV
+                  echo "GRIM_GIT_ORG=${{ github.repository_owner }}" >> $GITHUB_ENV
+
+            - name: Compute version and Build with Gradle
+              id: build_with_version
+              run: |
+                  # If any command in a pipeline fails, treat the pipeline as failed.
+                  set -o pipefail
+                  
+                  BUILD_ARGS="build"
+                  if [[ "${{ inputs.is-release-build }}" == "true" ]]; then
+                    BUILD_ARGS="$BUILD_ARGS -Prelease=true"
+                  fi
+                  # Conditionally add the --scan flag
+                  if [[ "${{ inputs.run-build-scan }}" == "true" ]]; then
+                    BUILD_ARGS="$BUILD_ARGS --scan"
+                  fi
+                  
+                  echo "Running: ./gradlew printVersion $BUILD_ARGS"
+                  
+                  # Use 'tee' to both display the output live and save it to a file for parsing
+                  VERSION=$(./gradlew printVersion $BUILD_ARGS | tee build-output.log | grep '^VERSION=' | tail -n1 | cut -d'=' -f2)
+                  
+                  echo "build_version=$VERSION" >> $GITHUB_OUTPUT
+                  echo "BUILD_VERSION=$VERSION" >> $GITHUB_ENV
+                  echo "Build version: $VERSION"
+
+            - name: Publish Build Scan URL
+                # Only run this step if a scan was requested
+              if: ${{ inputs.run-build-scan == true }}
+              run: |
+                  # Search the log file for the build scan URL and extract it
+                  SCAN_URL=$(grep -o 'https://gradle.com/s/[^ ]*' build-output.log | head -n 1 || true)
+                  
+                  if [[ -n "$SCAN_URL" ]]; then
+                    echo "Found build scan URL: $SCAN_URL"
+                    # Post a highly visible link to the Job Summary page
+                    echo "### Gradle Build Scan" >> $GITHUB_STEP_SUMMARY
+                    echo "A public build scan has been published and is available for inspection." >> $GITHUB_STEP_SUMMARY
+                    echo "" >> $GITHUB_STEP_SUMMARY
+                    echo "[**View Build Scan →**]($SCAN_URL)" >> $GITHUB_STEP_SUMMARY
+                  else
+                    echo "Could not find build scan URL in build-output.log" >> $GITHUB_STEP_SUMMARY
+                  fi
+
+            - name: Upload Bukkit Artifact
+              uses: actions/upload-artifact@v4
+              with:
+                  name: grimac-bukkit
+                  path: ${{ github.workspace }}/bukkit/build/libs/grimac-bukkit-${{ env.BUILD_VERSION }}.jar
+                  if-no-files-found: error
+
+            - name: Upload Fabric Artifact
+              uses: actions/upload-artifact@v4
+              with:
+                  name: grimac-fabric
+                  path: ${{ github.workspace }}/fabric/build/libs/grimac-fabric-${{ env.BUILD_VERSION }}.jar
+                  if-no-files-found: error
+
+            #------------------------------------------------------------------
+            #  Generate/Prepare Changelog
+            #------------------------------------------------------------------
+            - name: Generate Changelog with git-cliff (for Dev Builds)
+              if: ${{ !inputs.is-release-build }}
+              id: git-cliff
+              uses: orhun/git-cliff-action@v4
+              with:
+                  config: cliff.toml
+                  args: --verbose ${{ github.event.before }}..${{ github.event.after }}
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # git-cliff needs a token
+
+            - name: Prepare Final Changelog
+              id: changelog
+                # Add this 'env' block to safely load the changelogs as environment variables
+              env:
+                  RELEASE_NOTES: ${{ inputs.release-changelog }}
+                  DEV_NOTES: ${{ steps.git-cliff.outputs.content }}
+              run: |
+                  NOTES=""
+                  if [[ "${{ inputs.is-release-build }}" == "true" ]]; then
+                    # Use the environment variable for the release changelog.
+                    # The double quotes are critical to preserve newlines!
+                    NOTES="$RELEASE_NOTES"
+                  else
+                    # Use the environment variable for the dev changelog.
+                    NOTES="$DEV_NOTES"
+                  fi
+                  
+                  if [ -z "$NOTES" ]; then
+                    NOTES="* No new code changes in this build."
+                  fi
+                  
+                  # This is the correct way to set a multi-line output variable in Actions
+                  {
+                    echo "notes<<EOF"
+                    echo "$NOTES"
+                    echo "EOF"
+                  } >> "$GITHUB_OUTPUT"
+            #------------------------------------------------------------------
+            #  Publish to Modrinth & API
+            #------------------------------------------------------------------
+            - name: Publish Bukkit to Modrinth
+              if: ${{ inputs.publish-artifacts == true && env.MODRINTH_ID != '' && env.MODRINTH_TOKEN != '' }}
+              uses: Kir-Antipov/mc-publish@v3.3
+              with:
+                  modrinth-id:    ${{ secrets.MODRINTH_ID }}
+                  modrinth-token: ${{ secrets.MODRINTH_TOKEN }}
+                  modrinth-featured: ${{ inputs.is-release-build }} # Only feature release builds
+
+                  files: bukkit/build/libs/grimac-bukkit-${{ env.BUILD_VERSION }}.jar
+                  name: Grim Anticheat (Bukkit) ${{ env.BUILD_VERSION }}
+                  version: ${{ env.BUILD_VERSION }}
+                  version-type: ${{ inputs.release-version-type }}
+                  changelog: ${{ steps.changelog.outputs.notes }}
+                  loaders: |
+                    bukkit
+                    spigot
+                    paper
+                    folia
+                    purpur
+                  game-versions: '>=1.7 <=1.21.8'
+
+            - name: Publish Fabric to Modrinth
+              if: ${{ inputs.publish-artifacts == true && env.MODRINTH_ID != '' && env.MODRINTH_TOKEN != '' }}
+              uses: Kir-Antipov/mc-publish@v3.3
+              with:
+                  modrinth-id:    ${{ secrets.MODRINTH_ID }}
+                  modrinth-token: ${{ secrets.MODRINTH_TOKEN }}
+                  modrinth-featured: ${{ inputs.is-release-build }} # Only feature release builds
+
+                  files: fabric/build/libs/grimac-fabric-${{ env.BUILD_VERSION }}.jar
+                  name: Grim Anticheat (Fabric) ${{ env.BUILD_VERSION }}
+                  version: ${{ env.BUILD_VERSION }}
+                  version-type: ${{ inputs.release-version-type }}
+                  changelog: ${{ steps.changelog.outputs.notes }}
+                  loaders: |
+                      fabric
+                  game-versions: '>=1.16.1 <=1.21.8'
+                  dependencies: 'fabric-api'
+
+            - name: Publish to API
+              if: ${{ inputs.publish-artifacts == true && env.BUILD_UPDATE_TOKEN != '' }}
+              run: |
+                  curl -X POST \
+                    -H "Content-Type: application/json" \
+                    -H "User-Agent: GrimACBuilder/v1" \
+                    -H "Authorization: Bearer ${{ secrets.BUILD_UPDATE_TOKEN }}" \
+                    -d '{"org": "${{ github.repository_owner }}", "repository": "${{ github.event.repository.name }}", "branch": "${{ github.ref_name }}", "version": "${{ env.BUILD_VERSION }}"}' \
+                    "${{ secrets.BUILD_UPDATE_URL }}"

.github/workflows/codeql-analysis.yml

@@ -12,13 +12,9 @@
 name: "CodeQL"
 
 on:
+  workflow_dispatch:
   push:
-    branches: [ master ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ master ]
-  schedule:
-    - cron: '30 15 * * 2'
+    branches: [ dev ]
 
 jobs:
   analyze:
@@ -32,14 +28,14 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        language: [ 'java' ]
+        language: [ 'java-kotlin' ]
         # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
         # Learn more:
         # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
@@ -51,6 +47,14 @@ jobs:
           # Prefix the list here with "+" to use these queries and those in the config file.
           # queries: ./path/to/local/query, your-org/your-repo/queries@main
 
+      - name: Set up JDK 21
+        uses: actions/setup-java@v5
+        with:
+            java-version: '21'
+            distribution: 'temurin'
+            server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
+            settings-path: ${{ github.workspace }} # location for the settings.xml file
+
       # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
       # If this step fails, then you should remove it and run the build manually (see below)
       - name: Autobuild

.github/workflows/gradle-publish.yml

@@ -1,38 +1,44 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-# This workflow will build a package using Gradle and then publish it to GitHub packages when a release is created
-# For more information see: https://github.com/actions/setup-java/blob/main/docs/advanced-usage.md#Publishing-using-gradle
-
-name: Gradle Package
+name: Gradle Package (Development)
 
 on:
-  [push, workflow_dispatch]
-
+    workflow_dispatch:
+        inputs:
+            run-build-scan:
+                description: 'Run with public build scan (adds --scan)'
+                required: true
+                type: boolean
+                default: false
+            publish-artifacts:
+                description: 'Upload to Modrinth & API? (Uncheck for a dry run)'
+                type: boolean
+                default: true
+    push:
+        branches:
+            - 'main'
+            - '2.0'
+            - 'dev'
+            - 'release'
+            - 'release/**'
+        paths:
+            - '.github/workflows/**'
+            - 'buildSrc/**'
+            - 'bukkit/**'
+            - 'common/**'
+            - 'fabric/**'
+            - '**.java'
+            - '**.kt'
+            - '**.kts'
+            - '**.toml'
 jobs:
-  build:
-
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Set up JDK 17
-      uses: actions/setup-java@v4
-      with:
-        java-version: '17'
-        distribution: 'temurin'
-        server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
-        settings-path: ${{ github.workspace }} # location for the settings.xml file
-
-    - name: Build with Gradle
-      uses: gradle/actions/setup-gradle@v3
-      with:
-        arguments: build
-    - name: Upload a Build Artifact
-      uses: actions/upload-artifact@v4
-      with:
-        path: /home/runner/work/Grim/Grim/build/libs/**.jar
+    call-build-workflow:
+        uses: ./.github/workflows/build-and-publish.yml
+        with:
+            is-release-build: false
+            release-version-type: alpha # Dev builds are always 'alpha'
+            run-build-scan: ${{ github.event.inputs.run-build-scan == 'true' }}
+            publish-artifacts: ${{ github.event.inputs.publish-artifacts != 'false' }}
+        secrets:
+            MODRINTH_ID: ${{ secrets.MODRINTH_ID }}
+            MODRINTH_TOKEN: ${{ secrets.MODRINTH_TOKEN }}
+            BUILD_UPDATE_TOKEN: ${{ secrets.BUILD_UPDATE_TOKEN }}
+            BUILD_UPDATE_URL: ${{ secrets.BUILD_UPDATE_URL }}

.github/workflows/release.yml

@@ -0,0 +1,21 @@
+name: Publish Release
+
+on:
+    release:
+        types: [published]
+
+jobs:
+    call-release-workflow:
+        uses: ./.github/workflows/build-and-publish.yml
+        with:
+            is-release-build: true
+            release-version-type: release # Official releases are 'release'
+            # Use the body of the GitHub Release as the changelog
+            release-changelog: ${{ github.event.release.body }}
+            run-build-scan: false
+            publish-artifacts: true
+        secrets:
+            MODRINTH_ID: ${{ secrets.MODRINTH_ID }}
+            MODRINTH_TOKEN: ${{ secrets.MODRINTH_TOKEN }}
+            BUILD_UPDATE_TOKEN: ${{ secrets.BUILD_UPDATE_TOKEN }}
+            BUILD_UPDATE_URL: ${{ secrets.BUILD_UPDATE_URL }}

.gitignore

@@ -19,6 +19,7 @@ build/
 .gradletasknamecache
 gradle-app.setting
 !gradle-wrapper.jar
+buildSrc/.kotlin
 
 ##############################
 ## IntelliJ
@@ -65,4 +66,10 @@ nb-configuration.xml
 ##############################
 ## OS X
 ##############################
-.DS_Store
+.DS_Store
+
+##############################
+## Fabric
+##############################
+run/
+fabric/run/

CONTRIBUTING.md

@@ -0,0 +1,40 @@
+# Contributing to GrimAC
+
+Thank you for your interest in contributing to GrimAC. This document outlines the guidelines for
+making pull
+requests to the project. *We're usually pretty lenient with pull requests, but this guide will help
+make the process go more smoothly.*
+
+### Pull Request Guidelines
+
+- **Compatibility**
+  - Any changes must be compatible with
+  the [supported environments](https://github.com/GrimAnticheat/Grim/wiki/Supported-environments) (Spigot, Paper, Folia, Fabric, etc.)
+  - The plugin must be compatible with minecraft versions 1.8 and higher. Exempting checks from specific versions is acceptable.
+  - The plugin must be able to run on Java 17 or higher. Changes that don't support Java 17 at runtime will not be accepted.
+
+- **Non-acceptable pull requests**
+  - Heuristic-based checks will not be accepted; however, basic rate limiting such as blocking attacks based on CPS is acceptable.
+  - Checks that can be easily circumvented that don't block packets or fix anything are likely to not be accepted.
+  - Checks or features that are too specific to a single environment or minecraft version are likely to not be accepted.
+  - Changes that require large or unnecessary dependencies will likely not be accepted.
+
+- **Pull request formatting**
+  - Create a new branch for your feature or fix when forking the repository.
+  - Reference related issues in your pull request description if applicable.
+  - Write clear and descriptive commit messages.
+
+- **Code styling**
+  - Add code comments for complex logic or significant changes.
+  - Try to keep your code clean and avoid duplication.
+  - Thoroughly test your changes before submitting your pull request.
+
+### Development Notes
+
+- GrimAC is built using [Gradle](https://gradle.org/) kotlin scripts.
+- Java 21 is currently required to build the project. A minimum of Java 17 is required to run it.
+
+### Questions & Support
+
+- Join our [Discord](https://discord.grim.ac) if you have questions or need assistance.
+- Refer to the [Wiki](https://github.com/GrimAnticheat/Grim/wiki) for project documentation.

README.md

@@ -1,29 +1,88 @@
-# GrimAC
+<div align="center">
+ <h1>GrimAC</h1>
 
-This project is considered feature complete for the 2.0 (open-source) branch of this project. If you would like a bugfix or enhancement and cannot sponsor the work, pull requests are welcome. You can join the [discord](https://discord.com/invite/kqQAhTmkUF) for jar releases & changelogs.
+ <div>
+  <a href="https://github.com/GrimAnticheat/Grim/actions/workflows/gradle-publish.yml">
+   <img alt="Workflow" src="https://img.shields.io/github/actions/workflow/status/GrimAnticheat/Grim/gradle-publish.yml?style=flat&logo=github"/>
+  </a>&nbsp;&nbsp;
+  <a href="https://modrinth.com/plugin/grimac">
+   <img alt="Modrinth" src="https://img.shields.io/modrinth/v/LJNGWSvH?style=flat&label=version&logo=modrinth">
+  </a>&nbsp;&nbsp;
+  <a href="https://modrinth.com/plugin/grimac#download">
+   <img alt="Downloads" src="https://img.shields.io/modrinth/dt/LJNGWSvH?style=flat&logo=modrinth&label=downloads&link=https%3A%2F%2Fmodrinth.com%2Fplugin%2Fgrimac%23download">
+  </a>&nbsp;&nbsp;
+  <a href="https://discord.grim.ac">
+   <img alt="Discord" src="https://img.shields.io/discord/811396969670901800?style=flat&label=discord&logo=discord">
+  </a>
+ </div>
+ <br>
+</div>
 
-GrimAC is an open source Minecraft anticheat designed for 1.21 and supports 1.8-1.21. It is free while in beta. It will eventually become paid and/or will include offering additional subscription based paid checks. Geyser players are fully exempt.
+GrimAC is an open source Minecraft anticheat designed to support the latest versions of Minecraft.
+It currently supports minecraft versions 1.8–1.21. Geyser players are fully exempt from the anticheat to prevent false positives.
+This project is considered feature-complete for the 2.0 (open-source) branch. If you would like a bug fix or enhancement and cannot sponsor the work, pull requests are welcome.
+A premium version is planned, which will offer additional subscription-based paid checks, such as heuristics.
 
-### Compiling through terminal/command prompt
-1. git clone https://github.com/GrimAnticheat/Grim.git (or click the green code button, download ZIP, then unzip it.)
-2. cd Grim
-3. ./gradlew build
-4. The final jar is located in build/libs
+## Downloads
 
-### API Information
-Grim's API allows you to integrate Grim into your own plugins. For more information, check out the API's GitHub repository [here](https://github.com/GrimAnticheat/GrimAPI).
+- Latest updates:
+  - **[Modrinth](https://modrinth.com/plugin/grimac)** *(recommended)*
+  - GitHub
+  artifacts: [Bukkit](https://nightly.link/GrimAnticheat/Grim/workflows/gradle-publish/2.0/grimac-bukkit.zip), [Fabric](https://nightly.link/GrimAnticheat/Grim/workflows/gradle-publish/2.0/grimac-fabric.zip) *(bleeding edge)*
+- Major releases only:
+  - ~~[Hangar](https://hangar.papermc.io/GrimAnticheat/GrimAnticheat)~~
+  - ~~[SpigotMC](https://www.spigotmc.org/resources/grim-anticheat.99923/)~~
 
-## Grim supremacy
+## Resources
 
-Here are the main cores that make Grim stand out against other anticheats
+- For documentation and examples visit the [Wiki](https://github.com/GrimAnticheat/Grim/wiki).
+- For answers to commonly asked questions visit the [FAQ](https://github.com/GrimAnticheat/Grim/wiki/FAQ).
+- For community support and project discussion join our [Discord](https://discord.grim.ac).
+
+
+## Pull Requests
+
+See [Contributing](CONTRIBUTING.md) for more information about contributing and what our guidelines
+are.
+
+
+## Requirements & Installation
+
+- Java 17 or higher. *For more details
+  see [Updating-to-Java-17](https://github.com/GrimAnticheat/Grim/wiki/Updating-to-Java-17).*
+- A Spigot, Paper, Folia, or Fabric server environment. *For more details
+  see [Supported-environments](https://github.com/GrimAnticheat/Grim/wiki/Supported-environments).*
+- If you use Geyser, place Floodgate on the backend server so grim can exempt bedrock players. Grim
+  cannot access the Floodgate API if it is on the proxy.
+- If you use ViaVersion, it should be on the backend server as movement is highly dependent on
+  client version.
+
+## Developer Plugin API
+
+Grim's plugin API allows you to integrate Grim into your own plugins. Visit
+the [plugin API repository](https://github.com/GrimAnticheat/GrimAPI) for the source code and more
+information.
+
+## Compiling From Source
+
+1. `git clone https://github.com/GrimAnticheat/Grim.git`
+2. `cd Grim`
+3. `./gradlew build`
+4. The final jars will compile into the `<platform>/build/libs` folders
+
+## Grim Supremacy
+
+What makes Grim stand out against other anticheats?
 
 ### Movement Simulation Engine
 
 * We have a 1:1 replication of the player's possible movements
-* This covers everything from basic walking, swimming, knockback, cobwebs, to bubble columns
-* It even covers riding entities from boats to pigs to striders
+    * This covers everything from basic walking, swimming, knockback, cobwebs, to bubble columns
+    * It even covers riding entities from boats to pigs to striders
 * Built upon covering edge cases to confirm accuracy
-* 1.13+ clients on 1.13+ servers, 1.12- clients on 1.13+ servers, 1.13+ clients on 1.12- servers, and 1.12- clients on 1.12- servers are all supported regardless of the large technical changes between these versions.
+* 1.13+ clients on 1.13+ servers, 1.12- clients on 1.13+ servers, 1.13+ clients on 1.12- servers,
+  and 1.12- clients on 1.12- servers are all supported regardless of the large technical changes
+  between these versions.
 * The order of collisions depends on the client version and is correct
 * Accounts for minor bounding box differences between versions, for example:
     * Single glass panes will be a + shape for 1.7-1.8 players and * for 1.9+ players
@@ -50,7 +109,8 @@ Here are the main cores that make Grim stand out against other anticheats
 * Per player, the cache allows for multithreaded design
 * Sending players fake blocks with packets is safe and does not lead to falses
 * The world is recreated for each player to allow lag compensation
-* Client sided blocks cause no issues with packet based blocks. Block glitching does not false the anticheat.
+* Client sided blocks cause no issues with packet based blocks. Block glitching does not false the
+  anticheat.
 
 ### Latency compensation
 

build.gradle.kts

@@ -1,184 +1,49 @@
-import net.minecrell.pluginyml.bukkit.BukkitPluginDescription.Permission
+/**
+ *          GrimAC Build Configuration
+ *
+ * Build Flags:
+ * -PshadePE=true   - Enables 'lite' mode
+ * -Prelocate=false - Adds 'no_relocate' modifier
+ * -Prelease=true   - Removes commit/modifiers for release build
+ *
+ * Logic in: buildSrc/versioning/BuildConfig.kt & VersionUtil.kt
+ */
 
-plugins {
-    id("java")
-    id("maven-publish")
-    id("com.github.johnrengelman.shadow") version "8.1.1"
-    id("io.freefair.lombok") version "8.6"
-    id("net.minecrell.plugin-yml.bukkit") version "0.6.0"
-    id("com.diffplug.spotless") version "6.25.0"
-}
+import versioning.BuildConfig
+import versioning.VersionUtil
 
-spotless {
-    java {
-        endWithNewline()
-        indentWithSpaces(4)
-        removeUnusedImports()
-        trimTrailingWhitespace()
-        targetExclude("build/generated/**/*")
-    }
-
-    kotlinGradle {
-        endWithNewline()
-        indentWithSpaces(4)
-        trimTrailingWhitespace()
-    }
-}
+BuildConfig.init(project)
 
+val baseVersion = "2.3.73"
 group = "ac.grim.grimac"
-version = "2.3.68"
-description = "Libre simulation anticheat designed for 1.21 with 1.8-1.21 support, powered by PacketEvents 2.0."
+version = VersionUtil.computeVersion(baseVersion)
+description = "Libre simulation anticheat designed for 1.21 with 1.8–1.21 support, powered by PacketEvents 2.0."
 
-java {
-    toolchain.languageVersion.set(JavaLanguageVersion.of(17))
-}
+ext["timestamp"] = System.currentTimeMillis().toString()
+ext["git_branch"] = VersionUtil.getGitBranch(true)
+ext["git_commit"] = VersionUtil.getGitCommitHash(true)
+ext["git_org"] = System.getenv("GRIM_GIT_ORG") ?: VersionUtil.getGitUser()
+ext["git_repo"] = System.getenv("GRIM_GIT_REPO") ?: "Grim"
 
-// Set to false for debug builds
-// You cannot live reload classes if the jar relocates dependencies
-// Checks Project properties -> environment variable -> defaults true
-val relocate: Boolean = project.findProperty("relocate")?.toString()?.toBoolean()
-    ?: System.getenv("RELOCATE_JAR")?.toBoolean()
-    ?: true
+println("Build configuration:")
+println("    shadePE            = ${BuildConfig.shadePE}")
+println("    relocate           = ${BuildConfig.relocate}")
+println("    mavenLocalOverride = ${BuildConfig.mavenLocalOverride}")
+println("    release            = ${BuildConfig.release}")
+println("    version            = $version")
 
-repositories {
-    mavenLocal()
-    maven("https://hub.spigotmc.org/nexus/content/repositories/snapshots/") // Spigot
-    maven("https://jitpack.io/") { // Grim API
-        content {
-            includeGroup("com.github.grimanticheat")
-        }
-    }
-    maven("https://repo.viaversion.com") // ViaVersion
-    maven("https://repo.aikar.co/content/groups/aikar/") // ACF
-    maven("https://nexus.scarsz.me/content/repositories/releases") // Configuralize
-    maven("https://repo.opencollab.dev/maven-snapshots/") // Floodgate
-    maven("https://repo.opencollab.dev/maven-releases/") // Cumulus (for Floodgate)
-    maven("https://repo.codemc.io/repository/maven-releases/") // PacketEvents
-    maven("https://repo.codemc.io/repository/maven-snapshots/")
-    mavenCentral()
-    // FastUtil, Discord-Webhooks
-}
-
-dependencies {
-    implementation("com.github.retrooper:packetevents-spigot:2.5.1-SNAPSHOT")
-    implementation("co.aikar:acf-paper:0.5.1-SNAPSHOT")
-    implementation("club.minnced:discord-webhooks:0.8.0") // Newer versions include kotlin-stdlib, which leads to incompatibility with plugins that use Kotlin
-    implementation("it.unimi.dsi:fastutil:8.5.13")
-    implementation("github.scarsz:configuralize:1.4.0")
-
-    //implementation("com.github.grimanticheat:grimapi:1193c4fa41")
-    // Used for local testing: implementation("ac.grim.grimac:GRIMAPI:1.0")
-    implementation("com.github.grimanticheat:grimapi:fc5634e444")
-
-    implementation("org.jetbrains:annotations:24.1.0")
-    compileOnly("org.geysermc.floodgate:api:2.0-SNAPSHOT")
-    compileOnly("org.spigotmc:spigot-api:1.18.2-R0.1-SNAPSHOT")
-    compileOnly("com.viaversion:viaversion-api:5.0.4-SNAPSHOT")
-    //
-    compileOnly("io.netty:netty-all:4.1.85.Final")
-}
-
-bukkit {
-    name = "GrimAC"
-    author = "GrimAC"
-    main = "ac.grim.grimac.GrimAC"
-    website = "https://grim.ac/"
-    apiVersion = "1.13"
-    foliaSupported = true
-
-    softDepend = listOf(
-        "ProtocolLib",
-        "ProtocolSupport",
-        "Essentials",
-        "ViaVersion",
-        "ViaBackwards",
-        "ViaRewind",
-        "Geyser-Spigot",
-        "floodgate",
-        "FastLogin"
-    )
-
-    permissions {
-        register("grim.alerts") {
-            description = "Receive alerts for violations"
-            default = Permission.Default.OP
-        }
-
-        register("grim.alerts.enable-on-join") {
-            description = "Enable alerts on join"
-            default = Permission.Default.OP
-        }
-
-        register("grim.performance") {
-            description = "Check performance metrics"
-            default = Permission.Default.OP
-        }
-
-        register("grim.profile") {
-            description = "Check user profile"
-            default = Permission.Default.OP
-        }
-
-        register("grim.brand") {
-            description = "Show client brands on join"
-            default = Permission.Default.OP
-        }
-
-        register("grim.sendalert") {
-            description = "Send cheater alert"
-            default = Permission.Default.OP
-        }
-
-        register("grim.nosetback") {
-            description = "Disable setback"
-            default = Permission.Default.FALSE
-        }
-
-        register("grim.nomodifypacket") {
-            description = "Disable modifying packets"
-            default = Permission.Default.FALSE
-        }
-
-        register("grim.exempt") {
-            description = "Exempt from all checks"
-            default = Permission.Default.FALSE
-        }
+tasks.register("printVersion") {
+    group = "versioning"
+    description = "Prints the computed project version"
+    doLast {
+        println("VERSION=$version")
     }
 }
 
-tasks.build {
-    dependsOn(tasks.shadowJar)
-    dependsOn(tasks.spotlessApply)
-}
-
-tasks.withType<JavaCompile> {
-    options.encoding = "UTF-8"
-}
-
-publishing.publications.create<MavenPublication>("maven") {
-    artifact(tasks["shadowJar"])
-}
-
-tasks.shadowJar {
-    minimize()
-    archiveFileName.set("${project.name}-${project.version}.jar")
-    if (relocate) {
-        relocate("io.github.retrooper.packetevents", "ac.grim.grimac.shaded.io.github.retrooper.packetevents")
-        relocate("com.github.retrooper.packetevents", "ac.grim.grimac.shaded.com.github.retrooper.packetevents")
-        relocate("co.aikar.commands", "ac.grim.grimac.shaded.acf")
-        relocate("co.aikar.locale", "ac.grim.grimac.shaded.locale")
-        relocate("club.minnced", "ac.grim.grimac.shaded.discord-webhooks")
-        relocate("github.scarsz.configuralize", "ac.grim.grimac.shaded.configuralize")
-        relocate("com.github.puregero", "ac.grim.grimac.shaded.com.github.puregero")
-        relocate("com.google.code.gson", "ac.grim.grimac.shaded.gson")
-        relocate("alexh", "ac.grim.grimac.shaded.maps")
-        relocate("it.unimi.dsi.fastutil", "ac.grim.grimac.shaded.fastutil")
-        relocate("net.kyori", "ac.grim.grimac.shaded.kyori")
-        relocate("okhttp3", "ac.grim.grimac.shaded.okhttp3")
-        relocate("okio", "ac.grim.grimac.shaded.okio")
-        relocate("org.yaml.snakeyaml", "ac.grim.grimac.shaded.snakeyaml")
-        relocate("org.json", "ac.grim.grimac.shaded.json")
-        relocate("org.intellij", "ac.grim.grimac.shaded.intellij")
-        relocate("org.jetbrains", "ac.grim.grimac.shaded.jetbrains")
+// ---------- Java Compile Optimization ----------
+subprojects {
+    tasks.withType<JavaCompile>().configureEach {
+        options.isFork = true
+        options.isIncremental = true
     }
 }

buildSrc/build.gradle.kts

@@ -0,0 +1,15 @@
+plugins {
+    `kotlin-dsl`
+    kotlin("plugin.serialization") version "1.9.0" // Use the same Kotlin version as your main project
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation(libs.spotless)
+    implementation(libs.lombok)
+    implementation(libs.shadow)
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
+}

buildSrc/settings.gradle.kts

@@ -0,0 +1,7 @@
+dependencyResolutionManagement {
+    versionCatalogs {
+        create("libs") {
+            from(files("../libs.versions.toml"))
+        }
+    }
+}

buildSrc/src/main/kotlin/grim.base-conventions.gradle.kts

@@ -0,0 +1,90 @@
+import versioning.BuildConfig
+
+plugins {
+    `java-library`
+    id("io.freefair.lombok")
+    id("com.diffplug.spotless")
+}
+
+group = rootProject.group
+version = rootProject.version
+description = rootProject.description
+
+// Java compilation settings
+java {
+    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
+    disableAutoTargetJvm()
+    withSourcesJar()
+    withJavadocJar()
+}
+
+// Spotless configuration
+spotless {
+    java {
+        endWithNewline()
+        indentWithSpaces(4)
+        removeUnusedImports()
+        trimTrailingWhitespace()
+        targetExclude("build/generated/**/*")
+    }
+
+    kotlinGradle {
+        endWithNewline()
+        indentWithSpaces(4)
+        trimTrailingWhitespace()
+    }
+}
+
+tasks {
+    withType<JavaCompile>().configureEach {
+        options.encoding = "UTF-8"
+        options.release.set(17)
+    }
+
+    build {
+        // Ensure spotlessApply runs before build
+        dependsOn(tasks.named("spotlessApply"))
+    }
+
+    // Process resources (e.g., for plugin metadata files)
+    processResources {
+        val properties = mapOf(
+            "timestamp" to rootProject.ext["timestamp"],
+            "version" to project.version.toString(),
+            "git_commit" to rootProject.ext["git_commit"],
+            "git_branch" to rootProject.ext["git_branch"],
+            "git_repo" to rootProject.ext["git_repo"],
+            "git_org" to rootProject.ext["git_org"],
+            "build_shade_pe" to BuildConfig.shadePE,
+            "build_relocate" to BuildConfig.relocate,
+            "build_release" to BuildConfig.release,
+        )
+
+        properties.forEach { (key, value) -> inputs.property(key, value) }
+
+        filesMatching(
+            listOf(
+                "bungee.yml",
+                "velocity-plugin.json",
+                "fabric.mod.json",
+                "grimac.properties"
+            )
+        ) {
+            expand(properties)
+        }
+    }
+
+    javadoc {
+        title = "${rootProject.name}-${project.name} v${rootProject.version}"
+        options.encoding = "UTF-8"
+        options.overview =
+            rootProject.file("buildSrc/src/main/resources/javadoc-overview.html").toString()
+        setDestinationDir(file("${project.layout.buildDirectory.asFile.get()}/docs/javadoc"))
+        options {
+            (this as CoreJavadocOptions).addBooleanOption("Xdoclint:none", true)
+        }
+    }
+}
+
+// Default tasks
+defaultTasks("build")

buildSrc/src/main/kotlin/grim.jij-conventions.gradle.kts

@@ -0,0 +1,407 @@
+import kotlinx.serialization.json.*
+import java.util.jar.JarFile
+import java.util.zip.ZipEntry
+
+plugins {
+    `java-library`
+}
+
+val jijDependencies: Configuration by project.configurations.creating {
+    isCanBeResolved = true
+    isCanBeConsumed = false
+    extendsFrom(project.configurations.getByName("implementation"))
+    project.configurations.findByName("modImplementation")?.let { extendsFrom(it) }
+}
+
+data class DependencyIdentifier(
+    val group: String,
+    val name: String,
+    val version: String,
+    val classifier: String = "" // Add classifier field, default to empty string
+) {
+    override fun toString() = "$group:$name:$version${if (classifier.isNotEmpty()) ":$classifier" else ""}"
+}
+
+// Does not support extracting classifiers but while the fabric standard is ambiguous on whether they can be included
+// It does not appear dependency classifiers are in use by any mod I am aware of or can find
+fun parseFabricModJson(jarFile: File, project: Project): Set<DependencyIdentifier> {
+    val nestedJars = mutableSetOf<DependencyIdentifier>()
+    try {
+        JarFile(jarFile).use { jar ->
+            val fabricModJsonEntry: ZipEntry? = jar.getEntry("fabric.mod.json")
+            if (fabricModJsonEntry != null) {
+                jar.getInputStream(fabricModJsonEntry).bufferedReader().use { reader ->
+                    val jsonContent = reader.readText()
+                    val jsonElement = Json.parseToJsonElement(jsonContent)
+                    val jsonObject = jsonElement.jsonObject
+                    val jarsArray = jsonObject["jars"]?.jsonArray ?: return@use
+                    jarsArray.forEach { jarEntry: JsonElement ->
+                        val filePath =
+                            jarEntry.jsonObject["file"]?.jsonPrimitive?.content ?: return@forEach
+                        project.logger.debug(
+                            "Found nested JAR in fabric.mod.json: {} in {}",
+                            filePath,
+                            jarFile
+                        )
+                        val jarName = filePath.substringAfterLast("/")
+                        val parts = jarName.removeSuffix(".jar").split("-")
+                        if (parts.size >= 2) {
+                            val inferredName = parts.dropLast(1).joinToString("-")
+                            val inferredVersion = parts.last()
+                            nestedJars.add(DependencyIdentifier("", inferredName, inferredVersion))
+                            project.logger.debug("Inferred nested dependency from fabric.mod.json: :$inferredName:$inferredVersion")
+                        }
+                    }
+                }
+            }
+        }
+    } catch (e: Exception) {
+        project.logger.error("Failed to parse fabric.mod.json in $jarFile: ${e.message}")
+    }
+    return nestedJars
+}
+
+fun extractEmbeddedJars(jarFile: File, project: Project): Set<DependencyIdentifier> {
+    val embeddedJars = mutableSetOf<DependencyIdentifier>()
+    embeddedJars.addAll(parseFabricModJson(jarFile, project)) // Retain existing logic for top-level fabric.mod.json parsing
+    try {
+        JarFile(jarFile).use { jar ->
+            val entries = jar.entries()
+            while (entries.hasMoreElements()) {
+                val entry = entries.nextElement()
+                val entryName = entry.name
+                if (entryName.endsWith(".jar") && (entryName.startsWith("META-INF/jarjar/") || entryName.startsWith(
+                        "libs/"
+                    ) || entryName.startsWith("META-INF/jars/"))
+                ) {
+                    project.logger.debug("Found embedded JAR: {} in {}", entryName, jarFile)
+                    val tempFile = File.createTempFile("embedded-", ".jar")
+                    tempFile.deleteOnExit()
+                    jar.getInputStream(entry).use { input ->
+                        tempFile.outputStream().use { output ->
+                            input.copyTo(output)
+                        }
+                    }
+                    JarFile(tempFile).use { embeddedJar ->
+                        val fabricModJsonEntry: ZipEntry? = embeddedJar.getEntry("fabric.mod.json")
+                        if (fabricModJsonEntry != null) {
+                            embeddedJar.getInputStream(fabricModJsonEntry).bufferedReader().use { reader ->
+                                val jsonContent = reader.readText()
+                                val jsonElement = Json.parseToJsonElement(jsonContent)
+                                val jsonObject = jsonElement.jsonObject
+
+                                // Extract id and parse into group
+                                val id = jsonObject["id"]?.jsonPrimitive?.content
+                                    ?: throw IllegalStateException("Missing 'id' in fabric.mod.json of embedded JAR: $entryName")
+                                val idWithDots = id.replace("_", ".")
+                                val lastDotIndex = idWithDots.lastIndexOf(".")
+                                val group = if (lastDotIndex != -1) idWithDots.take(lastDotIndex) else ""
+
+                                // Extract name and version from the JAR filename
+                                val jarName = entryName.substringAfterLast("/").removeSuffix(".jar")
+                                val (name, version) = parseNameAndVersionFromJarName(jarName)
+                                    ?: throw IllegalStateException("Could not parse name and version from JAR filename: $jarName")
+
+                                // Create DependencyIdentifier (classifier is empty for now)
+                                val depId = DependencyIdentifier(group, name, version)
+                                embeddedJars.add(depId)
+                                project.logger.debug("Identified embedded dependency from fabric.mod.json and filename: {}", depId)
+                            }
+                        } else {
+                            project.logger.error("No fabric.mod.json found in embedded JAR: {}. Skipping.", entryName)
+                        }
+                    }
+                }
+            }
+        }
+    } catch (e: Exception) {
+        project.logger.error("Failed to analyze JAR file $jarFile for embedded JARs: ${e.message}")
+    }
+    return embeddedJars
+}
+
+fun parseNameAndVersionFromJarName(jarName: String): Pair<String, String>? {
+    val versionStartRegex = Regex("-(?=\\d)")
+    // Use regex to find the position of the hyphen followed by a digit
+    val versionStartMatch = versionStartRegex.find(jarName) ?: return null
+    val versionStartIndex = versionStartMatch.range.first
+
+    // Split the JAR name into name and version at the version start index
+    val name = jarName.take(versionStartIndex)
+    val version = jarName.substring(versionStartIndex + 1) // Skip the hyphen
+
+    return if (name.isNotEmpty() && version.isNotEmpty()) {
+        Pair(name, version)
+    } else {
+        null
+    }
+}
+
+fun shouldExcludeDependency(
+    dependency: ResolvedDependency,
+    allEmbeddedDependencies: Set<DependencyIdentifier>,
+    actuallyIncludedDependencies: Set<DependencyIdentifier>,
+    project: Project
+): Boolean {
+    val group = dependency.moduleGroup
+    val name = dependency.moduleName
+    val version = dependency.moduleVersion
+    // Extract classifier from resolved dependency (if available)
+    val classifier = dependency.moduleArtifacts.firstOrNull()?.classifier ?: ""
+    val depId = DependencyIdentifier(group, name, version, classifier)
+
+    if (group.startsWith("net.minecraft") ||
+        group.startsWith("net.fabricmc") ||
+        name == "minecraft" ||
+        name == "fabric-loader" ||
+        name == "fastutil" ||
+        name.startsWith("fabric_") ||
+        name.startsWith("fabric-api")
+    ) {
+        project.logger.debug("Excluding platform dependency: {}", depId)
+        return true
+    }
+
+    if (name.endsWith("-bom") || name.contains("_bom")) {
+        project.logger.debug("Excluding BOM file: {}", depId)
+        return true
+    }
+
+    if (allEmbeddedDependencies.any { it.name == name && it.version == version && it.classifier == classifier }) {
+        project.logger.debug("Excluding dependency already embedded in another JAR: {}", depId)
+        return true
+    }
+
+    if (actuallyIncludedDependencies.any { it.name == name && it.version == version && it.classifier == classifier }) {
+        project.logger.debug("Excluding duplicate dependency: {}", depId)
+        return true
+    }
+
+    return false
+}
+
+fun isJijTarget(
+    dependency: ResolvedDependency,
+    allEmbeddedDependencies: Set<DependencyIdentifier>,
+    actuallyIncludedDependencies: Set<DependencyIdentifier>,
+    project: Project
+): Boolean {
+    val classifier = dependency.moduleArtifacts.firstOrNull()?.classifier ?: ""
+    project.logger.debug(
+        "Checking JIJ target: {}",
+        DependencyIdentifier(
+            dependency.moduleGroup,
+            dependency.moduleName,
+            dependency.moduleVersion,
+            classifier
+        )
+    )
+    return !shouldExcludeDependency(
+        dependency,
+        allEmbeddedDependencies,
+        actuallyIncludedDependencies,
+        project
+    )
+}
+
+fun includeDependencyWithExclusions(
+    depId: DependencyIdentifier,
+    project: Project,
+    actuallyIncludedDependencies: MutableSet<DependencyIdentifier>,
+    allEmbeddedDependencies: Set<DependencyIdentifier>
+) {
+    project.logger.debug("Including external dependency as JIJ with dynamic exclusions: {}", depId)
+    project.dependencies {
+        // Include dependency with classifier (if present)
+        "include"("${depId.group}:${depId.name}:${depId.version}${if (depId.classifier.isNotEmpty()) ":${depId.classifier}" else ""}") {
+            allEmbeddedDependencies.forEach { embeddedDep ->
+                if (embeddedDep.group.isNotEmpty()) {
+                    exclude(group = embeddedDep.group, module = embeddedDep.name)
+                } else {
+                    exclude(module = embeddedDep.name)
+                }
+                project.logger.debug("Excluding embedded transitive dependency: ${embeddedDep.name}:${embeddedDep.version}${if (embeddedDep.classifier.isNotEmpty()) ":${embeddedDep.classifier}" else ""}")
+            }
+        }
+    }
+    actuallyIncludedDependencies.add(depId)
+}
+
+fun processDependencies(
+    dependencies: Set<ResolvedDependency>,
+    processed: MutableSet<String>,
+    allEmbeddedDependencies: MutableMap<DependencyIdentifier, File>,
+    actuallyIncludedDependencies: MutableSet<DependencyIdentifier>,
+    project: Project
+) {
+    dependencies.forEach { dep: ResolvedDependency ->
+        val classifier = dep.moduleArtifacts.firstOrNull()?.classifier ?: ""
+        val depKey = "${dep.moduleGroup}:${dep.moduleName}:${dep.moduleVersion}${if (classifier.isNotEmpty()) ":$classifier" else ""}"
+        val depId = DependencyIdentifier(dep.moduleGroup, dep.moduleName, dep.moduleVersion, classifier)
+        if (!processed.contains(depKey)) {
+            processed.add(depKey)
+            project.logger.debug("Resolved dependency: {}", depId)
+
+            val jarFile = dep.moduleArtifacts.firstOrNull()?.file
+            if (jarFile != null && jarFile.exists()) {
+                val embeddedJars = extractEmbeddedJars(jarFile, project)
+                embeddedJars.forEach { embeddedDep ->
+                    allEmbeddedDependencies[embeddedDep] = jarFile
+                }
+            }
+
+            if (isJijTarget(
+                    dep,
+                    allEmbeddedDependencies.keys,
+                    actuallyIncludedDependencies,
+                    project
+                )
+            ) {
+                project.logger.debug("Processing JIJ dependency: {}", depId)
+                val isProjectDependency = project.rootProject.allprojects.any { subproject ->
+                    subproject.name == dep.moduleName && (subproject.group == dep.moduleGroup || dep.moduleGroup.isEmpty())
+                }
+                if (isProjectDependency) {
+                    val projectPath = project.rootProject.allprojects.find { subproject ->
+                        subproject.name == dep.moduleName && (subproject.group == dep.moduleGroup || dep.moduleGroup.isEmpty())
+                    }?.path
+                        ?: throw IllegalStateException("Project dependency not found: ${dep.moduleName}")
+                    project.logger.debug("Including project dependency as JIJ: $projectPath")
+                    project.dependencies {
+                        "include"(project.project(projectPath))
+                    }
+                    actuallyIncludedDependencies.add(depId)
+                } else {
+                    includeDependencyWithExclusions(
+                        depId,
+                        project,
+                        actuallyIncludedDependencies,
+                        allEmbeddedDependencies.keys
+                    )
+                }
+            }
+
+            processDependencies(
+                dep.children,
+                processed,
+                allEmbeddedDependencies,
+                actuallyIncludedDependencies,
+                project
+            )
+        }
+    }
+}
+
+project.afterEvaluate {
+    project.logger.debug("Resolving jijDependencies configuration")
+    val resolvedDependencies = jijDependencies.resolvedConfiguration.firstLevelModuleDependencies
+
+    val processed = mutableSetOf<String>()
+    val allEmbeddedDependencies = mutableMapOf<DependencyIdentifier, File>()
+    val actuallyIncludedDependencies = mutableSetOf<DependencyIdentifier>()
+
+    fun collectAllEmbeddedDependenciesForAfterEvaluate(dependencies: Set<ResolvedDependency>) {
+        dependencies.forEach { dep ->
+            val classifier = dep.moduleArtifacts.firstOrNull()?.classifier ?: ""
+            val depKey = "${dep.moduleGroup}:${dep.moduleName}:${dep.moduleVersion}${if (classifier.isNotEmpty()) ":$classifier" else ""}"
+            if (!processed.contains(depKey)) {
+                processed.add(depKey)
+                val jarFile = dep.moduleArtifacts.firstOrNull()?.file
+                if (jarFile != null && jarFile.exists()) {
+                    val embeddedJars = extractEmbeddedJars(jarFile, project)
+                    embeddedJars.forEach { embeddedDep ->
+                        allEmbeddedDependencies[embeddedDep] = jarFile
+                        project.logger.debug(
+                            "Collected embedded dependency: {} from {}",
+                            embeddedDep,
+                            jarFile
+                        )
+                    }
+                }
+                collectAllEmbeddedDependenciesForAfterEvaluate(dep.children)
+            }
+        }
+    }
+
+    processed.clear()
+    collectAllEmbeddedDependenciesForAfterEvaluate(resolvedDependencies)
+
+    processed.clear()
+    processDependencies(
+        resolvedDependencies,
+        processed,
+        allEmbeddedDependencies,
+        actuallyIncludedDependencies,
+        project
+    )
+}
+
+tasks.withType<Jar>().configureEach {
+    doFirst {
+        project.logger.debug("Resolving JIJ dependencies for JAR inclusion")
+        val resolvedDependencies =
+            jijDependencies.resolvedConfiguration.firstLevelModuleDependencies
+        val processed = mutableSetOf<String>()
+        val allEmbeddedDependencies = mutableMapOf<DependencyIdentifier, File>()
+        val actuallyIncludedDependencies = mutableSetOf<DependencyIdentifier>()
+
+        fun collectAllEmbeddedDependenciesForJar(dependencies: Set<ResolvedDependency>) {
+            dependencies.forEach { dep ->
+                val depKey = "${dep.moduleGroup}:${dep.moduleName}:${dep.moduleVersion}"
+                if (!processed.contains(depKey)) {
+                    processed.add(depKey)
+                    val jarFile = dep.moduleArtifacts.firstOrNull()?.file
+                    if (jarFile != null && jarFile.exists()) {
+                        val embeddedJars = extractEmbeddedJars(jarFile, project)
+                        embeddedJars.forEach { embeddedDep ->
+                            allEmbeddedDependencies[embeddedDep] = jarFile
+                            project.logger.debug(
+                                "Collected embedded dependency for JAR: {} from {}",
+                                embeddedDep,
+                                jarFile
+                            )
+                        }
+                    }
+                    collectAllEmbeddedDependenciesForJar(dep.children)
+                }
+            }
+        }
+
+        processed.clear()
+        collectAllEmbeddedDependenciesForJar(resolvedDependencies)
+
+        processed.clear()
+
+        fun logDependencies(dependencies: Set<ResolvedDependency>) {
+            dependencies.forEach { dep ->
+                val depKey = "${dep.moduleGroup}:${dep.moduleName}:${dep.moduleVersion}"
+                val depId = DependencyIdentifier(dep.moduleGroup, dep.moduleName, dep.moduleVersion)
+                if (!processed.contains(depKey)) {
+                    processed.add(depKey)
+                    project.logger.debug("Resolved JIJ dependency for JAR: {}", depId)
+
+                    val jarFile = dep.moduleArtifacts.firstOrNull()?.file
+                    if (jarFile != null && jarFile.exists()) {
+                        val embeddedJars = extractEmbeddedJars(jarFile, project)
+                        embeddedJars.forEach { embeddedDep ->
+                            allEmbeddedDependencies[embeddedDep] = jarFile
+                        }
+                    }
+
+                    if (isJijTarget(
+                            dep,
+                            allEmbeddedDependencies.keys,
+                            actuallyIncludedDependencies,
+                            project
+                        )
+                    ) {
+                        project.logger.debug("Including JIJ dependency in JAR: {}", depId)
+                        actuallyIncludedDependencies.add(depId)
+                    }
+                    logDependencies(dep.children)
+                }
+            }
+        }
+        logDependencies(resolvedDependencies)
+    }
+}

buildSrc/src/main/kotlin/grim.shadow-conventions.gradle.kts

@@ -0,0 +1,41 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import versioning.BuildConfig
+
+plugins {
+    id("com.gradleup.shadow")
+}
+
+tasks.named<ShadowJar>("shadowJar") {
+    minimize()
+    archiveFileName = "${rootProject.name}-${project.name}-${rootProject.version}.jar"
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+
+    if (BuildConfig.relocate) {
+        if (BuildConfig.shadePE) {
+            relocate("io.github.retrooper.packetevents", "ac.grim.grimac.shaded.io.github.retrooper.packetevents")
+            relocate("com.github.retrooper.packetevents", "ac.grim.grimac.shaded.com.github.retrooper.packetevents")
+            relocate("net.kyori", "ac.grim.grimac.shaded.kyori") // use PE's built-in adventure instead when not shading PE
+        }
+        relocate("club.minnced", "ac.grim.grimac.shaded.discord-webhooks")
+        relocate("org.slf4j", "ac.grim.grimac.shaded.slf4j") // Required by discord-webhooks
+        relocate("github.scarsz.configuralize", "ac.grim.grimac.shaded.configuralize")
+        relocate("com.github.puregero", "ac.grim.grimac.shaded.com.github.puregero")
+        relocate("com.google.code.gson", "ac.grim.grimac.shaded.gson")
+        relocate("alexh", "ac.grim.grimac.shaded.maps")
+        relocate("it.unimi.dsi.fastutil", "ac.grim.grimac.shaded.fastutil")
+        relocate("okhttp3", "ac.grim.grimac.shaded.okhttp3")
+        relocate("okio", "ac.grim.grimac.shaded.okio")
+        relocate("org.yaml.snakeyaml", "ac.grim.grimac.shaded.snakeyaml")
+        relocate("org.json", "ac.grim.grimac.shaded.json")
+        relocate("org.intellij", "ac.grim.grimac.shaded.intellij")
+        relocate("org.jetbrains", "ac.grim.grimac.shaded.jetbrains")
+        relocate("org.incendo", "ac.grim.grimac.shaded.incendo")
+        relocate("io.leangen.geantyref", "ac.grim.grimac.shaded.geantyref") // Required by cloud
+        relocate("com.zaxxer", "ac.grim.grimac.shaded.zaxxer") // Database history
+    }
+    mergeServiceFiles()
+}
+
+tasks.named("assemble") {
+    dependsOn(tasks.named("shadowJar"))
+}

buildSrc/src/main/kotlin/versioning/BuildConfig.kt

@@ -0,0 +1,96 @@
+package versioning
+
+import org.gradle.api.Project
+import org.gradle.internal.extensions.stdlib.toDefaultLowerCase
+import versioning.BuildConfig.init
+import versioning.BuildConfig.mavenLocalOverride
+import versioning.BuildConfig.release
+import versioning.BuildConfig.relocate
+import versioning.BuildConfig.shadePE
+
+/**
+ * BuildConfig provides access to user-defined build flags that control how a Grim
+ * build is assembled. These flags are resolved once at configuration time using
+ * [init], and are then exposed as fast, memoized values.
+ *
+ * Flags can be defined in three ways:
+ *
+ *   1. JVM system properties  (-Dflag=value)
+ *   2. Gradle project properties  (-Pflag=value or in gradle.properties)
+ *   3. Environment variables  (FLAG=value)
+ *
+ * You can use these to enable/disable features like shading, relocation, or release mode.
+ *
+ * Examples:
+ *
+ * Using Gradle -P properties:
+ * ```
+ * ./gradlew build -PshadePE=true -Prelocate=false -Prelease=true
+ * ```
+ *
+ * Using environment variables:
+ * ```
+ * SHADE_PE=true RELOCATE_JAR=false RELEASE=true ./gradlew build
+ * ```
+ *
+ * Using JVM system properties:
+ * ```
+ * ./gradlew build -DshadePE=true -Drelease=true
+ * ```
+ *
+ * @property shadePE  If true, shades PacketEvents into the jar. Default: true.
+ * @property relocate If true, relocates shaded dependencies to avoid conflicts. Default: true.
+ * @property release  If true, omits commit hash and modifiers from version string. Default: false.
+ * @property mavenLocalOverride If true, will make artifacts in mavenLocal() will be used instead of their remote counterparts for this build. Default: false
+ */
+object BuildConfig {
+
+    /**
+     * Must be called once from your root build script to initialize the flags.
+     * Example (in build.gradle.kts):
+     * ```
+     * BuildConfig.init(project)
+     * ```
+     */
+    fun init(project: Project) {
+        _shadePE = resolveBool(project, "shadePE", altKey = "SHADE_PE", default = true)
+        _relocate = resolveBool(project, "relocate", altKey = "RELOCATE_JAR", default = true)
+        _release = resolveBool(project, "release", default = false)
+        _mavenLocalOverride = resolveBool(project, "mavenLocalOverride", default = false)
+    }
+
+    // Unified resolution logic (System > Gradle > Env)
+    private fun resolveRaw(project: Project, key: String): String? =
+        System.getProperty(key)                      // 1. JVM   (-Dkey=value)
+            ?: project.findProperty(key)?.toString() // 2. Gradle (-Pkey=value or gradle.properties)
+            ?: System.getenv(key.uppercase())        // 3. ENV   (KEY=value)
+
+    private fun resolveBool(project: Project, key: String, altKey: String? = null, default: Boolean): Boolean {
+        return resolveRaw(project, key)?.toDefaultLowerCase()?.toBooleanStrictOrNull()
+            ?: altKey?.let {
+                resolveRaw(project, it)?.toDefaultLowerCase()?.toBooleanStrictOrNull()
+            } ?: default
+    }
+
+    // Private backing vars (nullable because we can't use lateinit with primitives)
+    private var _shadePE: Boolean? = null
+    private var _relocate: Boolean? = null
+    private var _release: Boolean? = null
+    private var _mavenLocalOverride: Boolean? = null
+
+    /** If true, shades PacketEvents into the jar. Default: true. */
+    val shadePE: Boolean get() = _shadePE
+        ?: error("BuildConfig.shadePE accessed before init() was called")
+
+    /** If true, relocates shaded dependencies to avoid conflicts. Default: true. */
+    val relocate: Boolean get() = _relocate
+        ?: error("BuildConfig.relocate accessed before init() was called")
+
+    /** If true, omits commit hash and modifiers from version string. Default: false. */
+    val release: Boolean get() = _release
+        ?: error("BuildConfig.release accessed before init() was called")
+
+    val mavenLocalOverride: Boolean get() = _mavenLocalOverride
+        ?: error("BuildConfig.release accessed before init() was called")
+
+}

buildSrc/src/main/kotlin/versioning/VersionUtil.kt

@@ -0,0 +1,113 @@
+package versioning
+
+import java.io.ByteArrayOutputStream
+
+/**
+ * Utility for computing the version string of GrimAC artifacts.
+ *
+ * The version string is constructed based on:
+ * - A base semantic version (e.g., "2.3.72")
+ * - Git commit hash (unless in release mode)
+ * - Git branch name (unless in release mode or main)
+ * - Modifiers (e.g., lite, no_relocate) for non-default build configurations
+ *
+ * Example outputs:
+ * - `2.3.72` (release build)
+ * - `2.3.72-a4f8b21+lite` (preview build without PE shading)
+ * - `2.3.72-feature_branch-a4f8b21+lite-no_relocate`
+ *
+ * @see BuildConfig for controlling the release/modifier behavior
+ */
+object VersionUtil {
+
+    /**
+     * Computes the full version string for the build.
+     *
+     * @param baseVersion The base semantic version (e.g., "2.3.72")
+     * @return Full version string including commit hash, branch, and modifiers if applicable
+     */
+    fun computeVersion(baseVersion: String): String {
+        if (BuildConfig.release) {
+            return baseVersion
+        }
+
+        val commitHash = getGitCommitHash()
+        val branch = getGitBranch()
+
+        val modifiers = buildList {
+            if (!BuildConfig.shadePE) add("lite")
+            if (!BuildConfig.relocate) add("no_relocate")
+        }.joinToString("-").takeIf { it.isNotEmpty() }
+
+        return buildString {
+            append(baseVersion)
+            append("-")
+            branch?.let { append("$it-") }
+            append(commitHash)
+            modifiers?.let { append("+$it") }
+        }
+    }
+
+    /**
+     * Retrieves the current Git commit
+     */
+    fun getGitCommitHash(full: Boolean = false): String {
+        val stdout = ByteArrayOutputStream()
+        val command = listOfNotNull("git", "rev-parse", if (full) null else "--short", "HEAD")
+        ProcessBuilder(command)
+            .redirectErrorStream(true)
+            .start()
+            .apply { waitFor() }
+            .inputStream
+            .use { stdout.writeBytes(it.readAllBytes()) }
+        val fullCommit = stdout.toString().trim()
+        return fullCommit.take(minOf(fullCommit.length, 7))
+    }
+
+    /**
+     * Returns the current Git branch, sanitised for use in file names.
+     * If the branch is "main" or "2.0", returns null.
+     *
+     * Any slash (/) in the branch name is replaced with an underscore (_)
+     * to avoid filesystem issues.
+     */
+    fun getGitBranch(raw: Boolean = false): String? {
+        val stdout = ByteArrayOutputStream()
+
+        ProcessBuilder("git", "rev-parse", "--abbrev-ref", "HEAD")
+            .redirectErrorStream(true)
+            .start()
+            .apply { waitFor() }
+            .inputStream.use { stdout.writeBytes(it.readAllBytes()) }
+
+        if (raw) return stdout.toString().trim()
+
+        val branch = stdout.toString().trim()
+            .replace(Regex("[^a-zA-Z0-9_.-]+"), "_")
+            .replace(Regex("_{2,}"), "_")
+            .trim(' ', '.', '_', '-')
+            .removePrefix("heads_")
+
+        val mainBranch = System.getenv("GRIM_MAIN_BRANCH") ?: "2.0"
+
+        return when (branch) {
+            "main", mainBranch -> null                    // ← ignore these branches
+            else -> branch
+        }
+    }
+
+    fun getGitUser(): String {
+        try {
+            val stdout = ByteArrayOutputStream()
+            ProcessBuilder("git", "config", "user.name")
+                .redirectErrorStream(true)
+                .start()
+                .apply { waitFor() }
+                .inputStream.use { stdout.writeBytes(it.readAllBytes()) }
+            return stdout.toString().trim()
+        } catch (_: Exception) {
+            return "unknown"
+        }
+    }
+
+}

bukkit/build.gradle.kts

@@ -0,0 +1,206 @@
+import net.minecrell.pluginyml.bukkit.BukkitPluginDescription.Permission
+import versioning.BuildConfig
+
+plugins {
+    `maven-publish`
+    grim.`base-conventions`
+    grim.`shadow-conventions`
+    id("de.eldoria.plugin-yml.bukkit") version "0.8.0"
+    id("xyz.jpenilla.run-paper") version "3.0.0-beta.1"
+}
+
+repositories {
+    if (BuildConfig.mavenLocalOverride) {
+        mavenLocal()
+    }
+
+    // For paper-api
+    exclusiveContent {
+        forRepository {
+            maven {
+                name = "papermc"
+                url = uri("https://repo.papermc.io/repository/maven-public/")
+            }
+        }
+        filter {
+            includeGroup("io.papermc.paper")
+            includeGroup("net.md-5")
+        }
+    }
+
+    exclusiveContent {
+        forRepository {
+            maven("https://libraries.minecraft.net") { // Brigadier
+                mavenContent { releasesOnly() }
+            }
+        }
+        filter {
+            includeModule("com.mojang", "brigadier")
+        }
+    }
+
+    // For placeholderapi
+    exclusiveContent {
+        forRepository {
+            maven("https://repo.extendedclip.com/content/repositories/placeholderapi/")
+        }
+        filter {
+            includeGroup("me.clip")
+        }
+    }
+
+    // For GrimAPI and PacketEvents (transitive from :common, direct in :bukkit)
+    exclusiveContent {
+        forRepository {
+            maven("https://repo.grim.ac/snapshots")
+        }
+        filter {
+            includeGroup("ac.grim.grimac")
+            includeGroup("com.github.retrooper")
+        }
+    }
+
+    // For Configuralize (transitive from :common)
+    exclusiveContent {
+        forRepository {
+            maven("https://nexus.scarsz.me/content/repositories/releases") {
+                mavenContent { releasesOnly() }
+            }
+        }
+        filter {
+            includeGroup("github.scarsz")
+        }
+    }
+
+    // Maven Central Fallback
+    mavenCentral()
+}
+
+
+dependencies {
+    compileOnly(libs.paper.api)
+    compileOnly(libs.placeholderapi)
+
+    if (BuildConfig.shadePE) {
+        implementation(libs.packetevents.spigot)
+    } else {
+        compileOnly(libs.packetevents.spigot)
+    }
+    implementation(libs.cloud.paper)
+    implementation(libs.adventure.platform.bukkit)
+
+    implementation(project(":common"))
+    shadow(project(":common"))
+}
+
+bukkit {
+    name = "GrimAC"
+    author = "GrimAC"
+    main = "ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin"
+    website = "https://grim.ac/"
+    apiVersion = "1.13"
+    foliaSupported = true
+
+    if (!BuildConfig.shadePE) {
+        depend = listOf("packetevents")
+    }
+
+    softDepend = listOf(
+        "ProtocolLib",
+        "ProtocolSupport",
+        "Essentials",
+        "ViaVersion",
+        "ViaBackwards",
+        "ViaRewind",
+        "Geyser-Spigot",
+        "floodgate",
+        "FastLogin",
+        "PlaceholderAPI",
+    )
+
+    permissions {
+        register("grim.alerts") {
+            description = "Receive alerts for violations"
+            default = Permission.Default.OP
+        }
+
+        register("grim.alerts.enable-on-join") {
+            description = "Enable alerts on join"
+            default = Permission.Default.OP
+        }
+
+        register("grim.performance") {
+            description = "Check performance metrics"
+            default = Permission.Default.OP
+        }
+
+        register("grim.profile") {
+            description = "Check user profile"
+            default = Permission.Default.OP
+        }
+
+        register("grim.brand") {
+            description = "Show client brands on join"
+            default = Permission.Default.OP
+        }
+
+        register("grim.brand.enable-on-join") {
+            description = "Enable showing client brands on join"
+            default = Permission.Default.OP
+        }
+
+        register("grim.sendalert") {
+            description = "Send cheater alert"
+            default = Permission.Default.OP
+        }
+
+        register("grim.nosetback") {
+            description = "Disable setback"
+            default = Permission.Default.FALSE
+        }
+
+        register("grim.nomodifypacket") {
+            description = "Disable modifying packets"
+            default = Permission.Default.FALSE
+        }
+
+        register("grim.exempt") {
+            description = "Exempt from all checks"
+            default = Permission.Default.FALSE
+        }
+
+        register("grim.verbose") {
+            description = "Receive verbose alerts for violations"
+            default = Permission.Default.OP
+        }
+
+        register("grim.verbose.enable-on-join") {
+            description =
+                "Enable verbose alerts on join"
+            default = Permission.Default.FALSE
+        }
+
+        register("grim.list") {
+            description =
+                "Shows lists of specific data"
+            default = Permission.Default.FALSE
+        }
+
+    }
+}
+
+publishing.publications.create<MavenPublication>("maven") {
+    artifact(tasks["shadowJar"])
+}
+
+tasks {
+    runServer {
+        minecraftVersion("1.21.4")
+    }
+
+    shadowJar {
+        manifest {
+            attributes["paperweight-mappings-namespace"] = "mojang"
+        }
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/BukkitPlatformPlugin.java

@@ -0,0 +1,28 @@
+package ac.grim.grimac.platform.bukkit;
+
+import ac.grim.grimac.platform.api.PlatformPlugin;
+import org.bukkit.plugin.Plugin;
+
+public class BukkitPlatformPlugin implements PlatformPlugin {
+    private final Plugin plugin;
+
+    public BukkitPlatformPlugin(Plugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return plugin.isEnabled();
+    }
+
+    @Override
+    public String getName() {
+        return plugin.getName();
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public String getVersion() {
+        return plugin.getDescription().getVersion();
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/BukkitPlatformServer.java

@@ -0,0 +1,37 @@
+package ac.grim.grimac.platform.bukkit;
+
+import ac.grim.grimac.platform.api.PlatformServer;
+import ac.grim.grimac.platform.api.sender.Sender;
+import io.github.retrooper.packetevents.util.SpigotReflectionUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+
+
+public class BukkitPlatformServer implements PlatformServer {
+
+    @Override
+    public String getPlatformImplementationString() {
+        return Bukkit.getVersion();
+    }
+
+    @Override
+    public void dispatchCommand(Sender sender, String command) {
+        CommandSender commandSender = GrimACBukkitLoaderPlugin.LOADER.getBukkitSenderFactory().reverse(sender);
+        Bukkit.dispatchCommand(commandSender, command);
+    }
+
+    @Override
+    public Sender getConsoleSender() {
+        return GrimACBukkitLoaderPlugin.LOADER.getBukkitSenderFactory().map(Bukkit.getConsoleSender());
+    }
+
+    @Override
+    public void registerOutgoingPluginChannel(String name) {
+        GrimACBukkitLoaderPlugin.LOADER.getServer().getMessenger().registerOutgoingPluginChannel(GrimACBukkitLoaderPlugin.LOADER, name);
+    }
+
+    @Override
+    public double getTPS() {
+        return SpigotReflectionUtil.getTPS();
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/GrimACBukkitLoaderPlugin.java

@@ -0,0 +1,163 @@
+package ac.grim.grimac.platform.bukkit;
+
+import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.api.GrimAPIProvider;
+import ac.grim.grimac.api.GrimAbstractAPI;
+import ac.grim.grimac.api.plugin.GrimPlugin;
+import ac.grim.grimac.events.GrimExtensionManager;
+import ac.grim.grimac.manager.init.Initable;
+import ac.grim.grimac.manager.init.start.ExemptOnlinePlayersOnReload;
+import ac.grim.grimac.manager.init.start.StartableInitable;
+import ac.grim.grimac.platform.api.Platform;
+import ac.grim.grimac.platform.api.PlatformLoader;
+import ac.grim.grimac.platform.api.PlatformServer;
+import ac.grim.grimac.platform.api.manager.ItemResetHandler;
+import ac.grim.grimac.platform.api.manager.MessagePlaceHolderManager;
+import ac.grim.grimac.platform.api.manager.CommandAdapter;
+import ac.grim.grimac.platform.api.manager.PlatformPluginManager;
+import ac.grim.grimac.platform.api.player.PlatformPlayerFactory;
+import ac.grim.grimac.platform.api.scheduler.PlatformScheduler;
+import ac.grim.grimac.platform.api.sender.Sender;
+import ac.grim.grimac.platform.api.sender.SenderFactory;
+import ac.grim.grimac.platform.bukkit.initables.BukkitBStats;
+import ac.grim.grimac.platform.bukkit.initables.BukkitEventManager;
+import ac.grim.grimac.platform.bukkit.initables.BukkitTickEndEvent;
+import ac.grim.grimac.platform.bukkit.manager.BukkitItemResetHandler;
+import ac.grim.grimac.platform.bukkit.manager.BukkitMessagePlaceHolderManager;
+import ac.grim.grimac.platform.bukkit.manager.BukkitParserDescriptorFactory;
+import ac.grim.grimac.platform.bukkit.manager.BukkitPermissionRegistrationManager;
+import ac.grim.grimac.platform.bukkit.manager.BukkitPlatformPluginManager;
+import ac.grim.grimac.platform.bukkit.player.BukkitPlatformPlayerFactory;
+import ac.grim.grimac.platform.bukkit.resolver.BukkitResolverRegistrar;
+import ac.grim.grimac.platform.bukkit.scheduler.bukkit.BukkitPlatformScheduler;
+import ac.grim.grimac.platform.bukkit.scheduler.folia.FoliaPlatformScheduler;
+import ac.grim.grimac.platform.bukkit.sender.BukkitSenderFactory;
+import ac.grim.grimac.platform.bukkit.utils.placeholder.PlaceholderAPIExpansion;
+import ac.grim.grimac.utils.lazy.LazyHolder;
+import com.github.retrooper.packetevents.PacketEventsAPI;
+import io.github.retrooper.packetevents.factory.spigot.SpigotPacketEventsBuilder;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.plugin.ServicePriority;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.incendo.cloud.CommandManager;
+import org.incendo.cloud.brigadier.BrigadierSetting;
+import org.incendo.cloud.brigadier.CloudBrigadierManager;
+import org.incendo.cloud.bukkit.CloudBukkitCapabilities;
+import org.incendo.cloud.execution.ExecutionCoordinator;
+import org.incendo.cloud.paper.LegacyPaperCommandManager;
+import org.incendo.cloud.setting.Configurable;
+
+
+public final class GrimACBukkitLoaderPlugin extends JavaPlugin implements PlatformLoader {
+
+    public static GrimACBukkitLoaderPlugin LOADER;
+
+    private final LazyHolder<PlatformScheduler> scheduler = LazyHolder.simple(this::createScheduler);
+    private final LazyHolder<PacketEventsAPI<?>> packetEvents = LazyHolder.simple(() -> SpigotPacketEventsBuilder.build(this));
+    private final LazyHolder<BukkitSenderFactory> senderFactory = LazyHolder.simple(BukkitSenderFactory::new);
+    private final LazyHolder<CommandManager<Sender>> commandManager = LazyHolder.simple(this::createCommandManager);
+    private final LazyHolder<ItemResetHandler> itemResetHandler = LazyHolder.simple(BukkitItemResetHandler::new);
+
+    @Getter private final PlatformPlayerFactory platformPlayerFactory = new BukkitPlatformPlayerFactory();
+    @Getter private final CommandAdapter commandAdapter = new BukkitParserDescriptorFactory();
+    @Getter private final PlatformPluginManager pluginManager = new BukkitPlatformPluginManager();
+    @Getter private final GrimPlugin plugin;
+    @Getter private final PlatformServer platformServer = new BukkitPlatformServer();
+    @Getter private final MessagePlaceHolderManager messagePlaceHolderManager = new BukkitMessagePlaceHolderManager();
+    @Getter private final BukkitPermissionRegistrationManager permissionManager = new BukkitPermissionRegistrationManager();
+
+    public GrimACBukkitLoaderPlugin() {
+        GrimExtensionManager extensionManager = GrimAPI.INSTANCE.getExtensionManager();
+        BukkitResolverRegistrar registrar = new BukkitResolverRegistrar(extensionManager);
+        registrar.registerAll();
+        this.plugin = registrar.resolvePlugin(this);
+    }
+
+    @Override
+    public void onLoad() {
+        LOADER = this;
+        GrimAPI.INSTANCE.load(this, this.getBukkitInitTasks());
+    }
+
+    private Initable[] getBukkitInitTasks() {
+        return new Initable[] {
+                new ExemptOnlinePlayersOnReload(),
+                new BukkitEventManager(),
+                new BukkitTickEndEvent(),
+                new BukkitBStats(),
+                (StartableInitable) () -> {
+                    if (BukkitMessagePlaceHolderManager.hasPlaceholderAPI) {
+                        new PlaceholderAPIExpansion().register();
+                    }
+                }
+        };
+    }
+
+    @Override
+    public void onEnable() {
+        GrimAPI.INSTANCE.start();
+    }
+
+    @Override
+    public void onDisable() {
+        GrimAPI.INSTANCE.stop();
+    }
+
+    @Override
+    public PlatformScheduler getScheduler() {
+        return scheduler.get();
+    }
+
+    @Override
+    public PacketEventsAPI<?> getPacketEvents() {
+        return packetEvents.get();
+    }
+
+    @Override
+    public CommandManager<Sender> getCommandManager() {
+        return commandManager.get();
+    }
+
+    @Override
+    public ItemResetHandler getItemResetHandler() {
+        return itemResetHandler.get();
+    }
+
+    @Override
+    public SenderFactory<CommandSender> getSenderFactory() {
+        return senderFactory.get();
+    }
+
+    @Override
+    public void registerAPIService() {
+        GrimAPIProvider.init(GrimAPI.INSTANCE.getExternalAPI());
+        Bukkit.getServicesManager().register(GrimAbstractAPI.class, GrimAPI.INSTANCE.getExternalAPI(), GrimACBukkitLoaderPlugin.LOADER, ServicePriority.Normal);
+    }
+
+    private PlatformScheduler createScheduler() {
+        return GrimAPI.INSTANCE.getPlatform() == Platform.FOLIA ? new FoliaPlatformScheduler() : new BukkitPlatformScheduler();
+    }
+
+    private CommandManager<Sender> createCommandManager() {
+        LegacyPaperCommandManager<Sender> manager = new LegacyPaperCommandManager<>(
+                this,
+                ExecutionCoordinator.simpleCoordinator(),
+                senderFactory.get()
+        );
+        if (manager.hasCapability(CloudBukkitCapabilities.NATIVE_BRIGADIER)) {
+            manager.registerBrigadier();
+            CloudBrigadierManager<Sender, ?> cbm = manager.brigadierManager();
+            Configurable<BrigadierSetting> settings = cbm.settings();
+            settings.set(BrigadierSetting.FORCE_EXECUTABLE, true);
+        } else if (manager.hasCapability(CloudBukkitCapabilities.ASYNCHRONOUS_COMPLETION)) {
+            manager.registerAsynchronousCompletions();
+        }
+        return manager;
+    }
+
+    public BukkitSenderFactory getBukkitSenderFactory() {
+        return LOADER.senderFactory.get();
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/command/BukkitPlayerSelectorAdapter.java

@@ -0,0 +1,36 @@
+package ac.grim.grimac.platform.bukkit.command;
+
+import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.platform.api.command.PlayerSelector;
+import ac.grim.grimac.platform.api.sender.Sender;
+import ac.grim.grimac.platform.bukkit.sender.BukkitSenderFactory;
+import lombok.RequiredArgsConstructor;
+import org.incendo.cloud.bukkit.data.SinglePlayerSelector;
+
+import java.util.Collection;
+import java.util.Collections;
+
+@RequiredArgsConstructor
+public class BukkitPlayerSelectorAdapter implements PlayerSelector {
+    private final SinglePlayerSelector bukkitSelector;
+
+    @Override
+    public boolean isSingle() {
+        return true;
+    }
+
+    @Override
+    public Sender getSinglePlayer() {
+        return ((BukkitSenderFactory) GrimAPI.INSTANCE.getSenderFactory()).map(bukkitSelector.single());
+    }
+
+    @Override
+    public Collection<Sender> getPlayers() {
+        return Collections.singletonList(((BukkitSenderFactory) GrimAPI.INSTANCE.getSenderFactory()).map(bukkitSelector.single()));
+    }
+
+    @Override
+    public String inputString() {
+        return bukkitSelector.inputString();
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/command/BukkitPlayerSelectorParser.java

@@ -0,0 +1,28 @@
+package ac.grim.grimac.platform.bukkit.command;
+
+import ac.grim.grimac.platform.api.command.AbstractPlayerSelectorParser;
+import ac.grim.grimac.platform.api.command.PlayerSelector;
+import org.incendo.cloud.bukkit.parser.selector.SinglePlayerSelectorParser;
+import org.incendo.cloud.context.CommandContext;
+import org.incendo.cloud.parser.ParserDescriptor;
+
+import java.util.concurrent.CompletableFuture;
+
+public class BukkitPlayerSelectorParser<C> extends AbstractPlayerSelectorParser<C> {
+
+    @Override
+    public ParserDescriptor<C, PlayerSelector> descriptor() {
+        return super.createDescriptor();
+    }
+
+    @Override
+    protected ParserDescriptor<C, ?> getPlatformSpecificDescriptor() {
+        return SinglePlayerSelectorParser.singlePlayerSelectorParser();
+    }
+
+    @Override
+    protected CompletableFuture<PlayerSelector> adaptToCommonSelector(CommandContext<C> context, Object platformSpecificSelector) {
+        return CompletableFuture.completedFuture(new BukkitPlayerSelectorAdapter((org.incendo.cloud.bukkit.data.SinglePlayerSelector) platformSpecificSelector));
+    }
+
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/entity/BukkitGrimEntity.java

@@ -0,0 +1,104 @@
+package ac.grim.grimac.platform.bukkit.entity;
+
+import ac.grim.grimac.platform.api.entity.GrimEntity;
+import ac.grim.grimac.platform.api.world.PlatformWorld;
+import ac.grim.grimac.platform.bukkit.utils.convert.BukkitConversionUtils;
+import ac.grim.grimac.platform.bukkit.utils.reflection.PaperUtils;
+import ac.grim.grimac.platform.bukkit.world.BukkitPlatformWorld;
+import ac.grim.grimac.utils.math.Location;
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
+import org.bukkit.entity.Entity;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+public class BukkitGrimEntity implements GrimEntity {
+
+    protected static final boolean CAN_USE_DIRECT_GETTERS = PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_20_1) && PaperUtils.PAPER;
+
+    private final Entity entity;
+    private BukkitPlatformWorld bukkitPlatformWorld;
+
+    public BukkitGrimEntity(Entity entity) {
+        this.entity = Objects.requireNonNull(entity);
+    }
+
+    public Entity getBukkitEntity() {
+        return this.entity;
+    }
+
+    @Override
+    public UUID getUniqueId() {
+        return entity.getUniqueId();
+    }
+
+    @Override
+    public boolean eject() {
+        return entity.eject();
+    }
+
+    @Override
+    public CompletableFuture<Boolean> teleportAsync(Location location) {
+        org.bukkit.Location bLoc = BukkitConversionUtils.toBukkitLocation(location);
+        return PaperUtils.teleportAsync(this.entity, bLoc);
+    }
+
+    @Override
+    @NotNull
+    public Entity getNative() {
+        return entity;
+    }
+
+    @Override
+    public boolean isDead() {
+        return this.entity.isDead();
+    }
+
+    // TODO replace with PlayerWorldChangeEvent listener instead of checking for equality for better performance
+    @Override
+    public PlatformWorld getWorld() {
+        if (bukkitPlatformWorld == null || !bukkitPlatformWorld.getBukkitWorld().equals(entity.getWorld())) {
+            bukkitPlatformWorld = new BukkitPlatformWorld(entity.getWorld());
+        }
+
+        return bukkitPlatformWorld;
+    }
+
+    @Override
+    public Location getLocation() {
+        org.bukkit.Location location = this.entity.getLocation();
+        return new Location(
+                this.getWorld(),
+                location.getX(),
+                location.getY(),
+                location.getZ(),
+                location.getYaw(),
+                location.getPitch()
+        );
+    }
+
+    @Override
+    public double distanceSquared(double oX, double oY, double oZ) {
+        if (CAN_USE_DIRECT_GETTERS) {
+            double x = this.entity.getX();
+            double y = this.entity.getY();
+            double z = this.entity.getZ();
+            double distX = (x - oX) * (x - oX);
+            double distY = (y - oY) * (y - oY);
+            double distZ = (z - oZ) * (z - oZ);
+            return distX + distY + distZ;
+        } else {
+            org.bukkit.Location location = this.entity.getLocation();
+            double x = location.getX();
+            double y = location.getY();
+            double z = location.getZ();
+            double distX = (x - oX) * (x - oX);
+            double distY = (y - oY) * (y - oY);
+            double distZ = (z - oZ) * (z - oZ);
+            return distX + distY + distZ;
+        }
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/events/PistonEvent.java

@@ -1,10 +1,11 @@
-package ac.grim.grimac.events.bukkit;
+package ac.grim.grimac.platform.bukkit.events;
 
 import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.platform.bukkit.utils.convert.BukkitConversionUtils;
 import ac.grim.grimac.player.GrimPlayer;
-import ac.grim.grimac.utils.blockstate.helper.BlockFaceHelper;
 import ac.grim.grimac.utils.collisions.datatypes.SimpleCollisionBox;
 import ac.grim.grimac.utils.data.PistonData;
+import ac.grim.grimac.utils.data.TrackedPosition;
 import com.github.retrooper.packetevents.protocol.world.BlockFace;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
@@ -18,8 +19,20 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class PistonEvent implements Listener {
-    Material SLIME_BLOCK = Material.getMaterial("SLIME_BLOCK");
-    Material HONEY_BLOCK = Material.getMaterial("HONEY_BLOCK");
+
+    private final Material SLIME_BLOCK = Material.getMaterial("SLIME_BLOCK");
+    private final Material HONEY_BLOCK = Material.getMaterial("HONEY_BLOCK");
+
+    private static final double MAX_HORIZONTAL_DISTANCE = 24.0;
+    private static final double MAX_VERTICAL_DISTANCE = 64.0;
+
+    // accuracy isn't that important, it's close enough and performant
+    private static boolean isCloseEnough(final int aX, final int aY, final int aZ,
+                                         final double bX, final double bY, final double bZ) {
+        return Math.abs(aX - bX) <= MAX_HORIZONTAL_DISTANCE
+                && Math.abs(aY - bY) <= MAX_VERTICAL_DISTANCE
+                && Math.abs(aZ - bZ) <= MAX_HORIZONTAL_DISTANCE;
+    }
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onPistonPushEvent(BlockPistonExtendEvent event) {
@@ -55,10 +68,19 @@ public class PistonEvent implements Listener {
                         piston.getY() + event.getDirection().getModY(),
                         piston.getZ() + event.getDirection().getModZ()));
 
+        final int chunkX = event.getBlock().getX() >> 4;
+        final int chunkZ = event.getBlock().getZ() >> 4;
+        final BlockFace blockFace = BukkitConversionUtils.fromBukkitFace(event.getDirection());
+        final int sourceX = piston.getX();
+        final int sourceY = piston.getY();
+        final int sourceZ = piston.getZ();
+
         for (GrimPlayer player : GrimAPI.INSTANCE.getPlayerDataManager().getEntries()) {
-            if (player.compensatedWorld.isChunkLoaded(event.getBlock().getX() >> 4, event.getBlock().getZ() >> 4)) {
-                PistonData data = new PistonData(BlockFaceHelper.fromBukkitFace(event.getDirection()), boxes, player.lastTransactionSent.get(), true, hasSlimeBlock, hasHoneyBlock);
-                player.latencyUtils.addRealTimeTaskAsync(player.lastTransactionSent.get(), () -> player.compensatedWorld.activePistons.add(data));
+            TrackedPosition position = player.compensatedEntities.self.trackedServerPosition;
+            if (player.compensatedWorld.isChunkLoaded(chunkX, chunkZ) && isCloseEnough(sourceX, sourceY, sourceZ, position.getX(), position.getY(), position.getZ())) {
+                final int lastTrans = player.lastTransactionSent.get();
+                PistonData data = new PistonData(blockFace, boxes, lastTrans, true, hasSlimeBlock, hasHoneyBlock);
+                player.latencyUtils.addRealTimeTaskAsync(lastTrans, () -> player.compensatedWorld.activePistons.add(data));
             }
         }
     }
@@ -79,7 +101,7 @@ public class PistonEvent implements Listener {
         boolean hasHoneyBlock = false;
 
         List<SimpleCollisionBox> boxes = new ArrayList<>();
-        BlockFace face = BlockFaceHelper.fromBukkitFace(event.getDirection());
+        BlockFace face = BukkitConversionUtils.fromBukkitFace(event.getDirection());
 
         // The event was called without blocks and is therefore in the right direction
         if (event.getBlocks().isEmpty()) {
@@ -108,10 +130,19 @@ public class PistonEvent implements Listener {
             }
         }
 
+        final Block block = event.getBlock();
+        final int chunkX = block.getX() >> 4;
+        final int chunkZ = block.getZ() >> 4;
+        final int sourceX = block.getX();
+        final int sourceY = block.getY();
+        final int sourceZ = block.getZ();
+
         for (GrimPlayer player : GrimAPI.INSTANCE.getPlayerDataManager().getEntries()) {
-            if (player.compensatedWorld.isChunkLoaded(event.getBlock().getX() >> 4, event.getBlock().getZ() >> 4)) {
-                PistonData data = new PistonData(BlockFaceHelper.fromBukkitFace(event.getDirection()), boxes, player.lastTransactionSent.get(), false, hasSlimeBlock, hasHoneyBlock);
-                player.latencyUtils.addRealTimeTaskAsync(player.lastTransactionSent.get(), () -> player.compensatedWorld.activePistons.add(data));
+            TrackedPosition position = player.compensatedEntities.self.trackedServerPosition;
+            if (player.compensatedWorld.isChunkLoaded(chunkX, chunkZ) && isCloseEnough(sourceX, sourceY, sourceZ, position.getX(), position.getY(), position.getZ())) {
+                int lastTrans = player.lastTransactionSent.get();
+                PistonData data = new PistonData(face, boxes, lastTrans, false, hasSlimeBlock, hasHoneyBlock);
+                player.latencyUtils.addRealTimeTaskAsync(lastTrans, () -> player.compensatedWorld.activePistons.add(data));
             }
         }
     }

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/initables/BukkitBStats.java

@@ -0,0 +1,15 @@
+package ac.grim.grimac.platform.bukkit.initables;
+
+import ac.grim.grimac.manager.init.start.StartableInitable;
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import ac.grim.grimac.utils.anticheat.Constants;
+import io.github.retrooper.packetevents.bstats.bukkit.Metrics;
+
+public class BukkitBStats implements StartableInitable {
+    @Override
+    public void start() {
+        try {
+            new Metrics(GrimACBukkitLoaderPlugin.LOADER, Constants.BSTATS_PLUGIN_ID);
+        } catch (Exception ignored) {}
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/initables/BukkitEventManager.java

@@ -0,0 +1,15 @@
+package ac.grim.grimac.platform.bukkit.initables;
+
+import ac.grim.grimac.manager.init.start.StartableInitable;
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import ac.grim.grimac.platform.bukkit.events.PistonEvent;
+import ac.grim.grimac.utils.anticheat.LogUtil;
+import org.bukkit.Bukkit;
+
+public class BukkitEventManager implements StartableInitable {
+    public void start() {
+        LogUtil.info("Registering singular bukkit event... (PistonEvent)");
+
+        Bukkit.getPluginManager().registerEvents(new PistonEvent(), GrimACBukkitLoaderPlugin.LOADER);
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/initables/BukkitTickEndEvent.java

@@ -0,0 +1,94 @@
+package ac.grim.grimac.platform.bukkit.initables;
+
+import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.manager.init.start.AbstractTickEndEvent;
+import ac.grim.grimac.platform.api.Platform;
+import ac.grim.grimac.platform.bukkit.player.BukkitPlatformPlayer;
+import ac.grim.grimac.platform.bukkit.utils.reflection.PaperUtils;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.LogUtil;
+import ac.grim.grimac.utils.lists.HookedListWrapper;
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
+import com.github.retrooper.packetevents.util.reflection.Reflection;
+import io.github.retrooper.packetevents.util.SpigotReflectionUtil;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+import sun.misc.Unsafe;
+
+import java.lang.reflect.Field;
+import java.util.Collections;
+import java.util.List;
+
+// Copied from: https://github.com/ThomasOM/Pledge/blob/master/src/main/java/dev/thomazz/pledge/inject/ServerInjector.java
+@SuppressWarnings(value = {"unchecked", "deprecated"})
+public class BukkitTickEndEvent extends AbstractTickEndEvent implements Listener {
+
+    @Override
+    public void start() {
+        if (!super.shouldInjectEndTick()) {
+            return;
+        }
+        if (PacketEvents.getAPI().getServerManager().getVersion().isNewerThan(ServerVersion.V_1_11_2) && !Boolean.getBoolean("paper.explicit-flush")) {
+            LogUtil.warn("Reach.enable-post-packet=true but paper.explicit-flush=false, add \"-Dpaper.explicit-flush=true\" to your server's startup flags for fully functional extra reach accuracy.");
+        }
+        // this is necessary for folia
+        if (GrimAPI.INSTANCE.getPlatform() == Platform.FOLIA) {
+            PaperUtils.registerTickEndEvent(this, this::tickAllFoliaPlayers);
+            return;
+        }
+        // if it fails to inject, try to use paper's event
+        if (!injectWithReflection() && !PaperUtils.registerTickEndEvent(this, this::tickAllPlayers)) {
+            LogUtil.error("Failed to inject into the end of tick event!");
+        }
+    }
+
+    private void tickAllPlayers() {
+        for (GrimPlayer player : GrimAPI.INSTANCE.getPlayerDataManager().getEntries()) {
+            if (player.disableGrim) continue;
+            super.onEndOfTick(player);
+        }
+    }
+
+    private void tickAllFoliaPlayers() {
+        for (GrimPlayer player : GrimAPI.INSTANCE.getPlayerDataManager().getEntries()) {
+            if (player.disableGrim) continue;
+            if (player.platformPlayer == null) continue;
+            Player p = ((BukkitPlatformPlayer) player.platformPlayer).getNative();
+            if (!Bukkit.isOwnedByCurrentRegion(p)) continue;
+            super.onEndOfTick(player);
+        }
+    }
+
+    private boolean injectWithReflection() {
+        // Inject so we can add the final transaction pre-flush event
+        try {
+            Object connection = SpigotReflectionUtil.getMinecraftServerConnectionInstance();
+
+            Field connectionsList = Reflection.getField(connection.getClass(), List.class, 1);
+            List<Object> endOfTickObject = (List<Object>) connectionsList.get(connection);
+
+            // Use a list wrapper to check when the size method is called
+            // Unsure why synchronized is needed because the object itself gets synchronized
+            // but whatever.  At least plugins can't break it, I guess.
+            //
+            // Pledge injects into another list, so we should be safe injecting into this one
+            List<?> wrapper = Collections.synchronizedList(new HookedListWrapper<>(endOfTickObject) {
+                @Override
+                public void onIterator() {
+                    tickAllPlayers();
+                }
+            });
+
+            Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
+            unsafeField.setAccessible(true);
+            Unsafe unsafe = (Unsafe) unsafeField.get(null);
+            unsafe.putObject(connection, unsafe.objectFieldOffset(connectionsList), wrapper);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            LogUtil.error("Failed to inject into the end of tick event via reflection", e);
+            return false;
+        }
+        return true;
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/manager/BukkitItemResetHandler.java

@@ -0,0 +1,213 @@
+package ac.grim.grimac.platform.bukkit.manager;
+
+import ac.grim.grimac.platform.api.manager.ItemResetHandler;
+import ac.grim.grimac.platform.api.player.PlatformPlayer;
+import ac.grim.grimac.platform.bukkit.utils.reflection.PaperUtils;
+import ac.grim.grimac.utils.reflection.ReflectionUtils;
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
+import com.github.retrooper.packetevents.protocol.player.InteractionHand;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.EquipmentSlot;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+public class BukkitItemResetHandler implements ItemResetHandler {
+    private static final Consumer<Player> resetItemUsage;
+    private static final Predicate<Player> isUsingItem;
+    private static final Function<Player, InteractionHand> getItemUsageHand;
+
+    @Override
+    public void resetItemUsage(@Nullable PlatformPlayer player) {
+        if (player != null) resetItemUsage.accept((Player) player.getNative());
+    }
+
+    @Override
+    public @Nullable InteractionHand getItemUsageHand(@Nullable PlatformPlayer player) {
+        return player == null ? null : getItemUsageHand.apply((Player) player.getNative());
+    }
+
+    @Override
+    public boolean isUsingItem(@Nullable PlatformPlayer player) {
+        return player != null && isUsingItem.test((Player) player.getNative());
+    }
+
+    static {
+        final ServerVersion version = PacketEvents.getAPI().getServerManager().getVersion();
+
+        boolean legacy = version.isOlderThanOrEquals(ServerVersion.V_1_8_8);
+
+        try {
+            Method getHandle_ = null;
+
+            if (PaperUtils.PAPER && version.isNewerThanOrEquals(ServerVersion.V_1_20_5)) {
+                Class<?> cls = ReflectionUtils.getClass("org.bukkit.craftbukkit.entity.CraftLivingEntity");
+                if (cls != null) getHandle_ = cls.getMethod("getHandle");
+            }
+
+            boolean obfuscated = getHandle_ == null;
+            String nmsPackage = obfuscated ? Bukkit.getServer().getClass().getPackageName().split("\\.")[3] : null;
+
+            if (obfuscated) {
+                String clazzName = legacy ? "CraftHumanEntity" : "CraftLivingEntity";
+                getHandle_ = Class.forName("org.bukkit.craftbukkit." + nmsPackage + ".entity." + clazzName).getMethod("getHandle");
+            }
+
+            final Method getHandle = getHandle_;
+            Class<?> clazz = getHandle_.getReturnType();
+
+            if (version.isNewerThanOrEquals(ServerVersion.V_1_10)) {
+                isUsingItem = Player::isHandRaised;
+            } else {
+                Method method = clazz.getMethod(switch (Objects.requireNonNull(nmsPackage)) {
+                    case "v1_8_R3" -> "bS";
+                    case "v1_9_R1" -> "cs";
+                    case "v1_9_R2" -> "ct";
+                    default -> throw new IllegalStateException("You are using an unsupported server version! (" + version.getReleaseName() + ")");
+                });
+                isUsingItem = player -> {
+                    try {
+                        return (boolean) method.invoke(getHandle.invoke(player));
+                    } catch (IllegalAccessException | InvocationTargetException e) {
+                        throw new RuntimeException(e);
+                    }
+                };
+            }
+
+            if (legacy) {
+                getItemUsageHand = player -> isUsingItem.test(player) ? InteractionHand.MAIN_HAND : null;
+            } else if (PaperUtils.PAPER && version.isNewerThanOrEquals(ServerVersion.V_1_16_5)) {
+                getItemUsageHand = player -> player.isHandRaised()
+                        ? player.getHandRaised() == EquipmentSlot.OFF_HAND
+                        ? InteractionHand.OFF_HAND
+                        : InteractionHand.MAIN_HAND
+                        : null;
+            } else {
+                Method method = clazz.getMethod(switch (Objects.requireNonNull(nmsPackage)) {
+                    case "v1_9_R1" -> "ct";
+                    case "v1_9_R2" -> "cu";
+                    case "v1_10_R1" -> "cy";
+                    case "v1_11_R1" -> "cz";
+                    case "v1_12_R1" -> "cH";
+                    case "v1_13_R1", "v1_13_R2", "v1_14_R1" -> "cU";
+                    case "v1_15_R1", "v1_16_R1", "v1_16_R2", "v1_16_R3", "v1_17_R1" -> "getRaisedHand";
+                    case "v1_18_R1" -> "eM";
+                    case "v1_18_R2" -> "eN";
+                    case "v1_19_R1" -> "eU";
+                    case "v1_19_R2" -> "fa";
+                    case "v1_19_R3" -> "ff";
+                    case "v1_20_R1" -> "fj";
+                    case "v1_20_R2" -> "fn";
+                    case "v1_20_R3" -> "fo";
+                    case "v1_20_R4" -> "fw";
+                    case "v1_21_R1" -> "fs";
+                    case "v1_21_R2", "v1_21_R3", "v1_21_R4" -> "fA";
+                    case "v1_21_R5" -> "fH";
+                    case "v1_21_R6" -> "fP";
+                    default -> throw new IllegalStateException("You are using an unsupported server version! (" + version.getReleaseName() + ")");
+                });
+                getItemUsageHand = player -> {
+                    try {
+                        return isUsingItem.test(player)
+                                ? ((Enum<?>) method.invoke(getHandle.invoke(player))).ordinal() == 0
+                                ? InteractionHand.MAIN_HAND
+                                : InteractionHand.OFF_HAND
+                                : null;
+                    } catch (IllegalAccessException | InvocationTargetException e) {
+                        throw new RuntimeException(e);
+                    }
+                };
+            }
+
+            Method setLivingEntityFlag;
+
+            if (version.isNewerThanOrEquals(ServerVersion.V_1_19)) {
+                String name = obfuscated ? "c" : "setLivingEntityFlag";
+                setLivingEntityFlag = clazz.getDeclaredMethod(name, int.class, boolean.class);
+                setLivingEntityFlag.setAccessible(true);
+            } else {
+                setLivingEntityFlag = null;
+            }
+
+            if (PaperUtils.PAPER && version.isNewerThan(ServerVersion.V_1_17)) {
+                resetItemUsage = setLivingEntityFlag == null ? LivingEntity::clearActiveItem : player -> {
+                    try {
+                        setLivingEntityFlag.invoke(getHandle.invoke(player), 1, false);
+                    } catch (IllegalAccessException | InvocationTargetException e) {
+                        throw new RuntimeException(e);
+                    }
+                    player.clearActiveItem();
+                };
+            } else {
+                Method method = clazz.getMethod(switch (Objects.requireNonNull(nmsPackage)) {
+                    case "v1_8_R3" -> "bV";
+                    case "v1_9_R1" -> "cz";
+                    case "v1_9_R2" -> "cA";
+                    case "v1_10_R1" -> "cE";
+                    case "v1_11_R1" -> "cF";
+                    case "v1_12_R1" -> "cN";
+                    case "v1_13_R1", "v1_13_R2" -> "da";
+                    case "v1_14_R1" -> "dp";
+                    case "v1_15_R1" -> "dH";
+                    case "v1_16_R1", "v1_16_R2", "v1_16_R3", "v1_17_R1" -> "clearActiveItem";
+                    case "v1_18_R1" -> "eR";
+                    case "v1_18_R2" -> "eS";
+                    case "v1_19_R1" -> "eZ";
+                    case "v1_19_R2" -> "ff";
+                    case "v1_19_R3" -> "fk";
+                    case "v1_20_R1" -> "fo";
+                    case "v1_20_R2" -> "fs";
+                    case "v1_20_R3" -> "ft";
+                    case "v1_20_R4" -> "fB";
+                    case "v1_21_R1" -> "fx";
+                    case "v1_21_R2", "v1_21_R3", "v1_21_R4" -> "fF";
+                    case "v1_21_R5" -> "fM";
+                    case "v1_21_R6" -> "fU";
+                    default -> throw new IllegalStateException("You are using an unsupported server version! (" + version.getReleaseName() + ")");
+                });
+
+                if (legacy) { // 1.8.8
+                    resetItemUsage = player -> {
+                        try {
+                            method.invoke(getHandle.invoke(player));
+
+                            // in 1.8 we need to resync item usage manually,
+                            // only do so if the player is using an item
+                            if (isUsingItem.test(player)) player.updateInventory();
+                        } catch (IllegalAccessException | InvocationTargetException e) {
+                            throw new RuntimeException(e);
+                        }
+                    };
+                } else if (setLivingEntityFlag == null) { // 1.9-1.18.2
+                    resetItemUsage = player -> {
+                        try {
+                            method.invoke(getHandle.invoke(player));
+                        } catch (IllegalAccessException | InvocationTargetException e) {
+                            throw new RuntimeException(e);
+                        }
+                    };
+                } else { // 1.19+
+                    resetItemUsage = player -> {
+                        try {
+                            Object handle = getHandle.invoke(player);
+                            setLivingEntityFlag.invoke(handle, 1, false);
+                            method.invoke(handle);
+                        } catch (IllegalAccessException | InvocationTargetException e) {
+                            throw new RuntimeException(e);
+                        }
+                    };
+                }
+            }
+        } catch (Throwable t) {
+            throw t instanceof RuntimeException e ? e : new RuntimeException(t);
+        }
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/manager/BukkitMessagePlaceHolderManager.java

@@ -0,0 +1,19 @@
+package ac.grim.grimac.platform.bukkit.manager;
+
+import ac.grim.grimac.platform.api.manager.MessagePlaceHolderManager;
+import ac.grim.grimac.platform.api.player.PlatformPlayer;
+import ac.grim.grimac.platform.bukkit.player.BukkitPlatformPlayer;
+import com.github.retrooper.packetevents.util.reflection.Reflection;
+import me.clip.placeholderapi.PlaceholderAPI;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class BukkitMessagePlaceHolderManager implements MessagePlaceHolderManager {
+    public static final boolean hasPlaceholderAPI = Reflection.getClassByNameWithoutException("me.clip.placeholderapi.PlaceholderAPI") != null;
+
+    @Override
+    public @NotNull String replacePlaceholders(@Nullable PlatformPlayer player, @NotNull String string) {
+        if (!hasPlaceholderAPI) return string;
+        return PlaceholderAPI.setPlaceholders(player instanceof BukkitPlatformPlayer bukkitPlatformPlayer ? bukkitPlatformPlayer.getBukkitPlayer() : null, string);
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/manager/BukkitParserDescriptorFactory.java

@@ -0,0 +1,45 @@
+package ac.grim.grimac.platform.bukkit.manager;
+
+import ac.grim.grimac.platform.api.command.PlayerSelector;
+import ac.grim.grimac.platform.api.manager.CommandAdapter;
+import ac.grim.grimac.platform.api.sender.Sender;
+import ac.grim.grimac.platform.bukkit.command.BukkitPlayerSelectorParser;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.incendo.cloud.bukkit.BukkitCommandContextKeys;
+import org.incendo.cloud.parser.ParserDescriptor;
+import org.incendo.cloud.suggestion.Suggestion;
+import org.incendo.cloud.suggestion.SuggestionProvider;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public class BukkitParserDescriptorFactory implements CommandAdapter {
+
+    // Parser is kept as a field because its stateless
+    private final BukkitPlayerSelectorParser<Sender> bukkitPlayerSelectorParser = new BukkitPlayerSelectorParser<>();
+
+    @Override
+    public ParserDescriptor<Sender, PlayerSelector> singlePlayerSelectorParser() {
+        return bukkitPlayerSelectorParser.descriptor();
+    }
+
+    // TODO (Cross-platform) better + brigadier suggestions
+    @Override
+    public SuggestionProvider<Sender> onlinePlayerSuggestions() {
+        return (context, input) -> {
+            List<Suggestion> suggestions = new ArrayList<>();
+
+            for(Player player : Bukkit.getOnlinePlayers()) {
+                CommandSender bukkit = context.get(BukkitCommandContextKeys.BUKKIT_COMMAND_SENDER);
+                if (!(bukkit instanceof Player) || ((Player)bukkit).canSee(player)) {
+                    suggestions.add(Suggestion.suggestion(player.getName()));
+                }
+            }
+
+            return CompletableFuture.completedFuture(suggestions);
+        };
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/manager/BukkitPermissionRegistrationManager.java

@@ -0,0 +1,33 @@
+package ac.grim.grimac.platform.bukkit.manager;
+
+import ac.grim.grimac.platform.api.manager.PermissionRegistrationManager;
+import ac.grim.grimac.platform.api.permissions.PermissionDefaultValue;
+import ac.grim.grimac.platform.bukkit.utils.convert.BukkitConversionUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.permissions.Permission;
+
+public class BukkitPermissionRegistrationManager implements PermissionRegistrationManager {
+    /**
+     * Registers a permission with the specified default value on Bukkit.
+     * This method is only called for dynamic permissions (e.g., check-specific permissions
+     * like "grim.exempt.checkname") that are generated at runtime. Most other static permissions
+     * (e.g., "grim.exempt", "grim.alerts.enable-on-join") are registered with their defaults
+     * in the `plugin.yml` file, which is defined in the Bukkit Gradle build script.
+     *
+     * <p>Dynamic permissions are registered here to ensure they are available for autocomplete
+     * and permission checks immediately on startup. If the permission already exists, its default
+     * value is updated to match the specified value.</p>
+     *
+     * @param name         The permission node to register (e.g., "grim.exempt.checkname").
+     * @param defaultValue The default value for the permission.
+     */
+    @Override
+    public void registerPermission(String name, PermissionDefaultValue defaultValue) {
+        final Permission bukkitPermission = Bukkit.getPluginManager().getPermission(name);
+        if (bukkitPermission == null) {
+            Bukkit.getPluginManager().addPermission(new Permission(name, BukkitConversionUtils.toBukkitPermissionDefault(defaultValue)));
+        } else {
+            bukkitPermission.setDefault(BukkitConversionUtils.toBukkitPermissionDefault(defaultValue));
+        }
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/manager/BukkitPlatformPluginManager.java

@@ -0,0 +1,29 @@
+package ac.grim.grimac.platform.bukkit.manager;
+
+import ac.grim.grimac.platform.api.PlatformPlugin;
+import ac.grim.grimac.platform.api.manager.PlatformPluginManager;
+import ac.grim.grimac.platform.bukkit.BukkitPlatformPlugin;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.Nullable;
+
+public class BukkitPlatformPluginManager implements PlatformPluginManager {
+
+    @Override
+    public PlatformPlugin[] getPlugins() {
+        Plugin[] bukkitPlugins = Bukkit.getPluginManager().getPlugins();
+        PlatformPlugin[] plugins = new PlatformPlugin[bukkitPlugins.length];
+
+        for (int i = 0; i < bukkitPlugins.length; i++) {
+            plugins[i] = new BukkitPlatformPlugin(bukkitPlugins[i]);
+        }
+
+        return plugins;
+    }
+
+    @Override
+    public @Nullable PlatformPlugin getPlugin(String pluginName) {
+        Plugin bukkitPlugin = Bukkit.getPluginManager().getPlugin(pluginName);
+        return bukkitPlugin == null ? null : new BukkitPlatformPlugin(bukkitPlugin);
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/player/BukkitOfflinePlatformPlayer.java

@@ -0,0 +1,34 @@
+package ac.grim.grimac.platform.bukkit.player;
+
+import ac.grim.grimac.platform.api.player.OfflinePlatformPlayer;
+import lombok.RequiredArgsConstructor;
+import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+import java.util.UUID;
+
+@RequiredArgsConstructor
+public class BukkitOfflinePlatformPlayer implements OfflinePlatformPlayer {
+    private final OfflinePlayer offlinePlayer;
+
+    @Override
+    public boolean isOnline() {
+        return offlinePlayer.isOnline();
+    }
+
+    @Override
+    public @NotNull String getName() {
+        return Objects.requireNonNull(offlinePlayer.getName());
+    }
+
+    @Override
+    public @NotNull UUID getUniqueId() {
+        return offlinePlayer.getUniqueId();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof OfflinePlatformPlayer player && this.getUniqueId().equals(player.getUniqueId());
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/player/BukkitPlatformInventory.java

@@ -0,0 +1,64 @@
+package ac.grim.grimac.platform.bukkit.player;
+
+import ac.grim.grimac.platform.api.player.PlatformInventory;
+import com.github.retrooper.packetevents.protocol.item.ItemStack;
+import io.github.retrooper.packetevents.util.SpigotConversionUtil;
+import lombok.RequiredArgsConstructor;
+import org.bukkit.entity.Player;
+
+@RequiredArgsConstructor
+public class BukkitPlatformInventory implements PlatformInventory {
+
+    private final Player bukkitPlayer;
+
+    @Override
+    public ItemStack getItemInHand() {
+        return SpigotConversionUtil.fromBukkitItemStack(bukkitPlayer.getInventory().getItemInHand());
+    }
+
+    @Override
+    public ItemStack getItemInOffHand() {
+        return SpigotConversionUtil.fromBukkitItemStack(bukkitPlayer.getInventory().getItemInOffHand());
+    }
+
+    @Override
+    public ItemStack getStack(int bukkitSlot, int vanillaSlot) {
+        return SpigotConversionUtil.fromBukkitItemStack(bukkitPlayer.getInventory().getItem(bukkitSlot));
+    }
+
+    @Override
+    public ItemStack getHelmet() {
+        return SpigotConversionUtil.fromBukkitItemStack(bukkitPlayer.getInventory().getHelmet());
+    }
+
+    @Override
+    public ItemStack getChestplate() {
+        return SpigotConversionUtil.fromBukkitItemStack(bukkitPlayer.getInventory().getChestplate());
+    }
+
+    @Override
+    public ItemStack getLeggings() {
+        return SpigotConversionUtil.fromBukkitItemStack(bukkitPlayer.getInventory().getLeggings());
+    }
+
+    @Override
+    public ItemStack getBoots() {
+        return SpigotConversionUtil.fromBukkitItemStack(bukkitPlayer.getInventory().getBoots());
+    }
+
+    @Override
+    public ItemStack[] getContents() {
+        org.bukkit.inventory.ItemStack[] bukkitItems = bukkitPlayer.getInventory().getContents();
+        ItemStack[] items = new ItemStack[bukkitItems.length];
+        for (int i = 0; i < bukkitItems.length; i++) {
+            if (bukkitItems[i] == null) continue;
+            items[i] = SpigotConversionUtil.fromBukkitItemStack(bukkitItems[i]);
+        }
+        return items;
+    }
+
+    @Override
+    public String getOpenInventoryKey() {
+        return bukkitPlayer.getOpenInventory().getType().toString();
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/player/BukkitPlatformPlayer.java

@@ -0,0 +1,178 @@
+package ac.grim.grimac.platform.bukkit.player;
+
+import ac.grim.grimac.platform.api.entity.GrimEntity;
+import ac.grim.grimac.platform.api.player.PlatformInventory;
+import ac.grim.grimac.platform.api.player.PlatformPlayer;
+import ac.grim.grimac.platform.api.sender.Sender;
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import ac.grim.grimac.platform.bukkit.entity.BukkitGrimEntity;
+import ac.grim.grimac.platform.bukkit.utils.anticheat.MultiLibUtil;
+import ac.grim.grimac.platform.bukkit.utils.convert.BukkitConversionUtils;
+import ac.grim.grimac.platform.bukkit.utils.reflection.PaperUtils;
+import ac.grim.grimac.utils.common.arguments.CommonGrimArguments;
+import ac.grim.grimac.utils.math.Location;
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.protocol.player.GameMode;
+import com.github.retrooper.packetevents.protocol.player.User;
+import com.github.retrooper.packetevents.util.Vector3d;
+import io.github.retrooper.packetevents.util.SpigotConversionUtil;
+import lombok.Getter;
+import net.kyori.adventure.platform.bukkit.BukkitAudiences;
+import net.kyori.adventure.text.Component;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.permissions.Permission;
+import org.bukkit.permissions.PermissionDefault;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+public class BukkitPlatformPlayer extends BukkitGrimEntity implements PlatformPlayer {
+
+    private static final BukkitAudiences audiences = BukkitAudiences.create(GrimACBukkitLoaderPlugin.LOADER);
+
+    @Getter
+    private final Player bukkitPlayer;
+    @Getter
+    private final PlatformInventory inventory;
+
+    private final @Nullable User user;
+
+    public BukkitPlatformPlayer(Player bukkitPlayer) {
+        super(bukkitPlayer);
+        this.bukkitPlayer = bukkitPlayer;
+        this.inventory = new BukkitPlatformInventory(bukkitPlayer);
+        if (CommonGrimArguments.USE_CHAT_FAST_BYPASS.value()) {
+            Object channel = PacketEvents.getAPI().getProtocolManager().getChannel(bukkitPlayer.getUniqueId());
+            this.user = PacketEvents.getAPI().getProtocolManager().getUser(channel);
+        } else {
+            this.user = null;
+        }
+    }
+
+    @Override
+    public void kickPlayer(String textReason) {
+        bukkitPlayer.kickPlayer(textReason);
+    }
+
+    @Override
+    public boolean hasPermission(String s) {
+        return bukkitPlayer.hasPermission(s);
+    }
+
+    @Override
+    public boolean hasPermission(String s, boolean defaultIfUnset) {
+        return this.bukkitPlayer.hasPermission(new Permission(s, defaultIfUnset ? PermissionDefault.TRUE : PermissionDefault.FALSE));
+    }
+
+    @Override
+    public boolean isSneaking() {
+        return bukkitPlayer.isSneaking();
+    }
+
+    @Override
+    public void setSneaking(boolean isSneaking) {
+        bukkitPlayer.setSneaking(isSneaking);
+    }
+
+    @Override
+    public void sendMessage(String message) {
+        if (CommonGrimArguments.USE_CHAT_FAST_BYPASS.value() && user != null) {
+            user.sendMessage(message);
+        } else {
+            bukkitPlayer.sendMessage(message);
+        }
+    }
+
+    @Override
+    public void sendMessage(Component message) {
+        if (CommonGrimArguments.USE_CHAT_FAST_BYPASS.value() && user != null) {
+            user.sendMessage(message);
+        } else {
+            audiences.player(bukkitPlayer).sendMessage(message);
+        }
+    }
+
+    @Override
+    public boolean isOnline() {
+        return bukkitPlayer.isOnline();
+    }
+
+    @Override
+    public String getName() {
+        return bukkitPlayer.getName();
+    }
+
+    @Override
+    public void updateInventory() {
+        bukkitPlayer.updateInventory();
+    }
+
+    @Override
+    public Vector3d getPosition() {
+        if (CAN_USE_DIRECT_GETTERS) {
+            return new Vector3d(this.bukkitPlayer.getX(), this.bukkitPlayer.getY(), this.bukkitPlayer.getZ());
+        } else {
+            org.bukkit.Location location = this.bukkitPlayer.getLocation();
+            return new Vector3d(location.getX(), location.getY(), location.getZ());
+        }
+    }
+
+    @Override
+    public @Nullable GrimEntity getVehicle() {
+        return bukkitPlayer.getVehicle() == null ? null : new BukkitGrimEntity(bukkitPlayer.getVehicle());
+    }
+
+    @Override
+    public GameMode getGameMode() {
+        return SpigotConversionUtil.fromBukkitGameMode(bukkitPlayer.getGameMode());
+    }
+
+    @Override
+    public void setGameMode(GameMode gameMode) {
+        bukkitPlayer.setGameMode(SpigotConversionUtil.toBukkitGameMode(gameMode));
+    }
+
+    public World getBukkitWorld() {
+        return bukkitPlayer.getWorld();
+    }
+
+    @Override
+    public UUID getUniqueId() {
+        return bukkitPlayer.getUniqueId();
+    }
+
+    @Override
+    public boolean eject() {
+        return bukkitPlayer.eject();
+    }
+
+    @Override
+    public CompletableFuture<Boolean> teleportAsync(Location location) {
+        org.bukkit.Location bLoc = BukkitConversionUtils.toBukkitLocation(location);
+        return PaperUtils.teleportAsync(this.bukkitPlayer, bLoc);
+    }
+
+    @Override
+    public boolean isExternalPlayer() {
+        return MultiLibUtil.isExternalPlayer(this.bukkitPlayer);
+    }
+
+    @Override
+    public void sendPluginMessage(String channelName, byte[] byteArray) {
+        this.bukkitPlayer.sendPluginMessage(GrimACBukkitLoaderPlugin.LOADER, channelName, byteArray);
+    }
+
+    @Override
+    public Sender getSender() {
+        return GrimACBukkitLoaderPlugin.LOADER.getBukkitSenderFactory().map(this.bukkitPlayer);
+    }
+
+    @Override
+    @NotNull
+    public Player getNative() {
+        return this.bukkitPlayer;
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/player/BukkitPlatformPlayerFactory.java

@@ -0,0 +1,57 @@
+package ac.grim.grimac.platform.bukkit.player;
+
+import ac.grim.grimac.platform.api.player.AbstractPlatformPlayerFactory;
+import ac.grim.grimac.platform.api.player.OfflinePlatformPlayer;
+import ac.grim.grimac.platform.api.player.PlatformPlayer;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.UUID;
+
+
+public class BukkitPlatformPlayerFactory extends AbstractPlatformPlayerFactory<Player> {
+
+    @Override
+    protected Player getNativePlayer(@NotNull UUID uuid) {
+        return Bukkit.getPlayer(uuid);
+    }
+
+    @Override
+    protected Player getNativePlayer(@NotNull String name) {
+        return Bukkit.getPlayer(name);
+    }
+
+    @Override
+    protected PlatformPlayer createPlatformPlayer(@NotNull Player nativePlayer) {
+        return new BukkitPlatformPlayer(nativePlayer);
+    }
+
+    @Override
+    protected UUID getPlayerUUID(@NotNull Player nativePlayer) {
+        return nativePlayer.getUniqueId();
+    }
+
+    // The cast is safe because Bukkit.getOnlinePlayers() is guaranteed to contain Player or its subtypes,
+    // and we're only reading from it.
+    @Override
+    @SuppressWarnings("unchecked")
+    protected Collection<Player> getNativeOnlinePlayers() {
+        // Cast Collection<? extends Player> to Collection<Player>
+        return (Collection<Player>) Bukkit.getOnlinePlayers();
+    }
+
+    @Override
+    public OfflinePlatformPlayer getOfflineFromUUID(@NotNull UUID uuid) {
+        OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(uuid);
+        return new BukkitOfflinePlatformPlayer(offlinePlayer);
+    }
+
+    @Override
+    public OfflinePlatformPlayer getOfflineFromName(@NotNull String name) {
+        OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(name);
+        return new BukkitOfflinePlatformPlayer(offlinePlayer);
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/resolver/BukkitResolverRegistrar.java

@@ -0,0 +1,111 @@
+package ac.grim.grimac.platform.bukkit.resolver;
+
+import ac.grim.grimac.api.plugin.BasicGrimPlugin;
+import ac.grim.grimac.api.plugin.GrimPlugin;
+import ac.grim.grimac.events.GrimExtensionManager;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginDescriptionFile;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Manages the registration of Bukkit-specific resolvers with the GrimExtensionManager.
+ * This class is designed to be instantiated once during plugin startup.
+ */
+public final class BukkitResolverRegistrar {
+
+    private final GrimExtensionManager extensionManager;
+
+    // Cache to ensure we only create one GrimPlugin wrapper per Bukkit Plugin instance.
+    private final Map<Plugin, GrimPlugin> pluginCache = new ConcurrentHashMap<>();
+
+    public BukkitResolverRegistrar(GrimExtensionManager extensionManager) {
+        this.extensionManager = extensionManager;
+    }
+
+    /**
+     * Registers all the Bukkit-specific resolvers in order of performance (fastest to slowest).
+     */
+    public void registerAll() {
+        extensionManager.setFailureHandler(this::createFailureException);
+        extensionManager.registerResolver(this::resolvePluginInstance);
+        extensionManager.registerResolver(this::resolveStringName);
+        extensionManager.registerResolver(this::resolveClass);
+    }
+
+    /**
+     * The core logic for converting a Bukkit Plugin into a GrimPlugin, with caching.
+     */
+    public GrimPlugin resolvePlugin(Plugin bukkitPlugin) {
+        return pluginCache.computeIfAbsent(bukkitPlugin, plugin -> {
+            PluginDescriptionFile desc = plugin.getDescription();
+            return new BasicGrimPlugin(
+                    plugin.getLogger(),
+                    plugin.getDataFolder(),
+                    desc.getVersion(),
+                    desc.getDescription(),
+                    desc.getAuthors()
+            );
+        });
+    }
+
+    /**
+     * 1. Resolver for raw Plugin instances (the most common case).
+     */
+    private GrimPlugin resolvePluginInstance(Object context) {
+        if (context instanceof Plugin bukkitPlugin) {
+            return resolvePlugin(bukkitPlugin);
+        }
+        return null;
+    }
+
+    /**
+     * 2. Resolver for String plugin names.
+     */
+    private GrimPlugin resolveStringName(Object context) {
+        if (context instanceof String pluginName) {
+            // Use the Bukkit API to look up the plugin by name. This returns null if not found.
+            Plugin bukkitPlugin = Bukkit.getPluginManager().getPlugin(pluginName);
+            // We must check for null before applying the logic to avoid a NullPointerException.
+            return (bukkitPlugin != null) ? resolvePlugin(bukkitPlugin) : null;
+        }
+        return null;
+    }
+
+    /**
+     * 3. Resolver for Class objects.
+     */
+    private GrimPlugin resolveClass(Object context) {
+        if (context instanceof Class) {
+            try {
+                // First, resolve the Class to a Plugin instance.
+                JavaPlugin providingPlugin = JavaPlugin.getProvidingPlugin((Class<?>) context);
+                // Then, use our shared logic directly to get the GrimPlugin wrapper.
+                return resolvePlugin(providingPlugin);
+            } catch (IllegalArgumentException | IllegalStateException e) {
+                // This is an expected failure if the class is not from a plugin
+                // or is called from a static initializer. We simply indicate that
+                // this resolver cannot handle this context.
+                return null;
+            }
+        }
+        // This resolver only handles Classes.
+        return null;
+    }
+
+    private RuntimeException createFailureException(Object failedContext) {
+        String message = """
+        Failed to resolve GrimPlugin context from the provided object of type '%s'.
+
+        Please ensure you are passing one of the following:
+          - The main instance of your plugin (e.g., 'this' from your class extending JavaPlugin).
+          - The plugin name as a String (e.g., "MyPluginName").
+          - Any Class from your plugin's JAR file (e.g., MyListener.class).
+          - A pre-existing GrimPlugin instance.
+        """.formatted(failedContext.getClass().getName());
+        return new IllegalArgumentException(message);
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/scheduler/bukkit/BukkitAsyncScheduler.java

@@ -0,0 +1,56 @@
+package ac.grim.grimac.platform.bukkit.scheduler.bukkit;
+
+import ac.grim.grimac.api.plugin.GrimPlugin;
+import ac.grim.grimac.platform.api.scheduler.AsyncScheduler;
+import ac.grim.grimac.platform.api.scheduler.PlatformScheduler;
+import ac.grim.grimac.platform.api.scheduler.TaskHandle;
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import org.bukkit.Bukkit;
+import org.bukkit.scheduler.BukkitScheduler;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.TimeUnit;
+
+public class BukkitAsyncScheduler implements AsyncScheduler {
+
+    private final BukkitScheduler bukkitScheduler = Bukkit.getScheduler();
+
+    @Override
+    public TaskHandle runNow(@NotNull GrimPlugin plugin, @NotNull Runnable task) {
+        return new BukkitTaskHandle(bukkitScheduler.runTaskAsynchronously(GrimACBukkitLoaderPlugin.LOADER, task));
+    }
+
+    @Override
+    public TaskHandle runDelayed(@NotNull GrimPlugin plugin, @NotNull Runnable task, long delay, @NotNull TimeUnit timeUnit) {
+        return new BukkitTaskHandle(bukkitScheduler.runTaskLaterAsynchronously(
+                GrimACBukkitLoaderPlugin.LOADER,
+                task,
+                PlatformScheduler.convertTimeToTicks(delay, timeUnit)
+        ));
+    }
+
+    @Override
+    public TaskHandle runAtFixedRate(@NotNull GrimPlugin plugin, @NotNull Runnable task, long delay, long period, @NotNull TimeUnit timeUnit) {
+        return new BukkitTaskHandle(bukkitScheduler.runTaskTimerAsynchronously(
+                GrimACBukkitLoaderPlugin.LOADER,
+                task,
+                PlatformScheduler.convertTimeToTicks(delay, timeUnit),
+                PlatformScheduler.convertTimeToTicks(period, timeUnit)
+        ));
+    }
+
+    @Override
+    public TaskHandle runAtFixedRate(@NotNull GrimPlugin plugin, @NotNull Runnable task, long initialDelayTicks, long periodTicks) {
+        return new BukkitTaskHandle(bukkitScheduler.runTaskTimerAsynchronously(
+                GrimACBukkitLoaderPlugin.LOADER,
+                task,
+                initialDelayTicks,
+                periodTicks
+        ));
+    }
+
+    @Override
+    public void cancel(@NotNull GrimPlugin plugin) {
+        bukkitScheduler.cancelTasks(GrimACBukkitLoaderPlugin.LOADER);
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/scheduler/bukkit/BukkitEntityScheduler.java

@@ -0,0 +1,35 @@
+package ac.grim.grimac.platform.bukkit.scheduler.bukkit;
+
+import ac.grim.grimac.api.plugin.GrimPlugin;
+import ac.grim.grimac.platform.api.entity.GrimEntity;
+import ac.grim.grimac.platform.api.scheduler.EntityScheduler;
+import ac.grim.grimac.platform.api.scheduler.TaskHandle;
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import org.bukkit.Bukkit;
+import org.bukkit.scheduler.BukkitScheduler;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class BukkitEntityScheduler implements EntityScheduler {
+    private final BukkitScheduler scheduler = Bukkit.getScheduler();
+
+    @Override
+    public void execute(@NotNull GrimEntity entity, @NotNull GrimPlugin plugin, @NotNull Runnable run, @Nullable Runnable retired, long delay) {
+        scheduler.runTaskLater(GrimACBukkitLoaderPlugin.LOADER, run, delay);
+    }
+
+    @Override
+    public TaskHandle run(@NotNull GrimEntity entity, @NotNull GrimPlugin plugin, @NotNull Runnable task, @Nullable Runnable retired) {
+        return new BukkitTaskHandle(scheduler.runTask(GrimACBukkitLoaderPlugin.LOADER, task));
+    }
+
+    @Override
+    public TaskHandle runDelayed(@NotNull GrimEntity entity, @NotNull GrimPlugin plugin, @NotNull Runnable task, @Nullable Runnable retired, long delayTicks) {
+        return new BukkitTaskHandle(scheduler.runTaskLater(GrimACBukkitLoaderPlugin.LOADER, task, delayTicks));
+    }
+
+    @Override
+    public TaskHandle runAtFixedRate(@NotNull GrimEntity entity, @NotNull GrimPlugin plugin, @NotNull Runnable task, @Nullable Runnable retired, long initialDelayTicks, long periodTicks) {
+        return new BukkitTaskHandle(scheduler.runTaskTimer(GrimACBukkitLoaderPlugin.LOADER, task, initialDelayTicks, periodTicks));
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/scheduler/bukkit/BukkitGlobalRegionScheduler.java

@@ -0,0 +1,39 @@
+package ac.grim.grimac.platform.bukkit.scheduler.bukkit;
+
+import ac.grim.grimac.api.plugin.GrimPlugin;
+import ac.grim.grimac.platform.api.scheduler.GlobalRegionScheduler;
+import ac.grim.grimac.platform.api.scheduler.TaskHandle;
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import org.bukkit.Bukkit;
+import org.bukkit.scheduler.BukkitScheduler;
+import org.jetbrains.annotations.NotNull;
+
+public class BukkitGlobalRegionScheduler implements GlobalRegionScheduler {
+
+    private final BukkitScheduler bukkitScheduler = Bukkit.getScheduler();
+
+    @Override
+    public void execute(@NotNull GrimPlugin plugin, @NotNull Runnable task) {
+        bukkitScheduler.runTask(GrimACBukkitLoaderPlugin.LOADER, task);
+    }
+
+    @Override
+    public TaskHandle run(@NotNull GrimPlugin plugin, @NotNull Runnable task) {
+        return new BukkitTaskHandle(bukkitScheduler.runTask(GrimACBukkitLoaderPlugin.LOADER, task));
+    }
+
+    @Override
+    public TaskHandle runDelayed(@NotNull GrimPlugin plugin, @NotNull Runnable task, long delay) {
+        return new BukkitTaskHandle(bukkitScheduler.runTaskLater(GrimACBukkitLoaderPlugin.LOADER, task, delay));
+    }
+
+    @Override
+    public TaskHandle runAtFixedRate(@NotNull GrimPlugin plugin, @NotNull Runnable task, long initialDelayTicks, long periodTicks) {
+        return new BukkitTaskHandle(bukkitScheduler.runTaskTimer(GrimACBukkitLoaderPlugin.LOADER, task, initialDelayTicks, periodTicks));
+    }
+
+    @Override
+    public void cancel(@NotNull GrimPlugin plugin) {
+        bukkitScheduler.cancelTasks(GrimACBukkitLoaderPlugin.LOADER);
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/scheduler/bukkit/BukkitPlatformScheduler.java

@@ -0,0 +1,13 @@
+package ac.grim.grimac.platform.bukkit.scheduler.bukkit;
+
+import ac.grim.grimac.platform.api.scheduler.PlatformScheduler;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+@Getter
+public class BukkitPlatformScheduler implements PlatformScheduler {
+    private final @NotNull BukkitAsyncScheduler asyncScheduler = new BukkitAsyncScheduler();
+    private final @NotNull BukkitGlobalRegionScheduler globalRegionScheduler = new BukkitGlobalRegionScheduler();
+    private final @NotNull BukkitEntityScheduler entityScheduler = new BukkitEntityScheduler();
+    private final @NotNull BukkitRegionScheduler regionScheduler = new BukkitRegionScheduler();
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/scheduler/bukkit/BukkitRegionScheduler.java

@@ -0,0 +1,56 @@
+package ac.grim.grimac.platform.bukkit.scheduler.bukkit;
+
+import ac.grim.grimac.api.plugin.GrimPlugin;
+import ac.grim.grimac.platform.api.scheduler.RegionScheduler;
+import ac.grim.grimac.platform.api.scheduler.TaskHandle;
+import ac.grim.grimac.platform.api.world.PlatformWorld;
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import ac.grim.grimac.utils.math.Location;
+import org.bukkit.Bukkit;
+import org.bukkit.scheduler.BukkitScheduler;
+import org.jetbrains.annotations.NotNull;
+
+public class BukkitRegionScheduler implements RegionScheduler {
+
+    private final BukkitScheduler bukkitScheduler = Bukkit.getScheduler();
+
+    @Override
+    public void execute(@NotNull GrimPlugin plugin, @NotNull PlatformWorld world, int chunkX, int chunkZ, @NotNull Runnable task) {
+        bukkitScheduler.runTask(GrimACBukkitLoaderPlugin.LOADER, task);
+    }
+
+    @Override
+    public void execute(@NotNull GrimPlugin plugin, @NotNull Location location, @NotNull Runnable task) {
+        bukkitScheduler.runTask(GrimACBukkitLoaderPlugin.LOADER, task);
+    }
+
+    @Override
+    public TaskHandle run(@NotNull GrimPlugin plugin, @NotNull PlatformWorld world, int chunkX, int chunkZ, @NotNull Runnable task) {
+        return new BukkitTaskHandle(bukkitScheduler.runTask(GrimACBukkitLoaderPlugin.LOADER, task));
+    }
+
+    @Override
+    public TaskHandle run(@NotNull GrimPlugin plugin, @NotNull Location location, @NotNull Runnable task) {
+        return new BukkitTaskHandle(bukkitScheduler.runTask(GrimACBukkitLoaderPlugin.LOADER, task));
+    }
+
+    @Override
+    public TaskHandle runDelayed(@NotNull GrimPlugin plugin, @NotNull PlatformWorld world, int chunkX, int chunkZ, @NotNull Runnable task, long delayTicks) {
+        return new BukkitTaskHandle(bukkitScheduler.runTaskLater(GrimACBukkitLoaderPlugin.LOADER, task, delayTicks));
+    }
+
+    @Override
+    public TaskHandle runDelayed(@NotNull GrimPlugin plugin, @NotNull Location location, @NotNull Runnable task, long delayTicks) {
+        return new BukkitTaskHandle(bukkitScheduler.runTaskLater(GrimACBukkitLoaderPlugin.LOADER, task, delayTicks));
+    }
+
+    @Override
+    public TaskHandle runAtFixedRate(@NotNull GrimPlugin plugin, @NotNull PlatformWorld world, int chunkX, int chunkZ, @NotNull Runnable task, long initialDelayTicks, long periodTicks) {
+        return new BukkitTaskHandle(bukkitScheduler.runTaskTimer(GrimACBukkitLoaderPlugin.LOADER, task, initialDelayTicks, periodTicks));
+    }
+
+    @Override
+    public TaskHandle runAtFixedRate(@NotNull GrimPlugin plugin, @NotNull Location location, @NotNull Runnable task, long initialDelayTicks, long periodTicks) {
+        return new BukkitTaskHandle(bukkitScheduler.runTaskTimer(GrimACBukkitLoaderPlugin.LOADER, task, initialDelayTicks, periodTicks));
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/scheduler/bukkit/BukkitTaskHandle.java

@@ -0,0 +1,33 @@
+package ac.grim.grimac.platform.bukkit.scheduler.bukkit;
+
+import ac.grim.grimac.platform.api.scheduler.TaskHandle;
+import org.bukkit.scheduler.BukkitTask;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class BukkitTaskHandle implements TaskHandle {
+
+    private final @NotNull BukkitTask task;
+
+    @Contract(pure = true)
+    public BukkitTaskHandle(@NotNull BukkitTask task) {
+        this.task = Objects.requireNonNull(task);
+    }
+
+    @Override
+    public boolean isSync() {
+        return task.isSync();
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return task.isCancelled();
+    }
+
+    @Override
+    public void cancel() {
+        task.cancel();
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/scheduler/folia/FoliaAsyncScheduler.java

@@ -0,0 +1,57 @@
+package ac.grim.grimac.platform.bukkit.scheduler.folia;
+
+import ac.grim.grimac.api.plugin.GrimPlugin;
+import ac.grim.grimac.platform.api.scheduler.AsyncScheduler;
+import ac.grim.grimac.platform.api.scheduler.TaskHandle;
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.TimeUnit;
+
+public class FoliaAsyncScheduler implements AsyncScheduler {
+
+    private final io.papermc.paper.threadedregions.scheduler.AsyncScheduler scheduler = Bukkit.getAsyncScheduler();
+
+    @Override
+    public TaskHandle runNow(@NotNull GrimPlugin plugin, @NotNull Runnable task) {
+        return new FoliaTaskHandle(scheduler.runNow(GrimACBukkitLoaderPlugin.LOADER, ignored -> task.run()));
+    }
+
+    @Override
+    public TaskHandle runDelayed(@NotNull GrimPlugin plugin, @NotNull Runnable task, long delay, @NotNull TimeUnit timeUnit) {
+        return new FoliaTaskHandle(scheduler.runDelayed(
+                GrimACBukkitLoaderPlugin.LOADER,
+                ignored -> task.run(),
+                delay,
+                timeUnit
+        ));
+    }
+
+    @Override
+    public TaskHandle runAtFixedRate(@NotNull GrimPlugin plugin, @NotNull Runnable task, long delay, long period, @NotNull TimeUnit timeUnit) {
+        return new FoliaTaskHandle(scheduler.runAtFixedRate(
+                GrimACBukkitLoaderPlugin.LOADER,
+                ignored -> task.run(),
+                delay,
+                period,
+                timeUnit
+        ));
+    }
+
+    @Override
+    public TaskHandle runAtFixedRate(@NotNull GrimPlugin plugin, @NotNull Runnable task, long initialDelayTicks, long periodTicks) {
+        return new FoliaTaskHandle(scheduler.runAtFixedRate(
+                GrimACBukkitLoaderPlugin.LOADER,
+                ignored -> task.run(),
+                initialDelayTicks * 50,
+                periodTicks * 50,
+                TimeUnit.MILLISECONDS
+        ));
+    }
+
+    @Override
+    public void cancel(@NotNull GrimPlugin plugin) {
+        scheduler.cancelTasks(GrimACBukkitLoaderPlugin.LOADER);
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/scheduler/folia/FoliaEntityScheduler.java

@@ -0,0 +1,55 @@
+package ac.grim.grimac.platform.bukkit.scheduler.folia;
+
+import ac.grim.grimac.api.plugin.GrimPlugin;
+import ac.grim.grimac.platform.api.entity.GrimEntity;
+import ac.grim.grimac.platform.api.scheduler.EntityScheduler;
+import ac.grim.grimac.platform.api.scheduler.TaskHandle;
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import ac.grim.grimac.platform.bukkit.entity.BukkitGrimEntity;
+import io.papermc.paper.threadedregions.scheduler.ScheduledTask;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class FoliaEntityScheduler implements EntityScheduler {
+
+    @Override
+    public void execute(@NotNull GrimEntity entity, @NotNull GrimPlugin plugin, @NotNull Runnable task, @Nullable Runnable retired, long delay) {
+        ((BukkitGrimEntity) entity).getBukkitEntity().getScheduler().execute(GrimACBukkitLoaderPlugin.LOADER, task, retired, delay);
+    }
+
+    @Override
+    public TaskHandle run(@NotNull GrimEntity entity, @NotNull GrimPlugin plugin, @NotNull Runnable task, @Nullable Runnable retired) {
+        ScheduledTask scheduled = ((BukkitGrimEntity) entity).getBukkitEntity().getScheduler().run(
+                GrimACBukkitLoaderPlugin.LOADER,
+                ignored -> task.run(),
+                retired
+        );
+
+        return scheduled == null ? null : new FoliaTaskHandle(scheduled);
+    }
+
+    @Override
+    public TaskHandle runDelayed(@NotNull GrimEntity entity, @NotNull GrimPlugin plugin, @NotNull Runnable task, @Nullable Runnable retired, long delayTicks) {
+        ScheduledTask scheduled = ((BukkitGrimEntity) entity).getBukkitEntity().getScheduler().runDelayed(
+                GrimACBukkitLoaderPlugin.LOADER,
+                ignored -> task.run(),
+                retired,
+                delayTicks
+        );
+
+        return scheduled == null ? null : new FoliaTaskHandle(scheduled);
+    }
+
+    @Override
+    public TaskHandle runAtFixedRate(@NotNull GrimEntity entity, @NotNull GrimPlugin plugin, @NotNull Runnable task, @Nullable Runnable retired, long initialDelayTicks, long periodTicks) {
+        ScheduledTask scheduled = ((BukkitGrimEntity) entity).getBukkitEntity().getScheduler().runAtFixedRate(
+                GrimACBukkitLoaderPlugin.LOADER,
+                ignored -> task.run(),
+                retired,
+                initialDelayTicks,
+                periodTicks
+        );
+
+        return scheduled == null ? null : new FoliaTaskHandle(scheduled);
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/scheduler/folia/FoliaGlobalRegionScheduler.java

@@ -0,0 +1,38 @@
+package ac.grim.grimac.platform.bukkit.scheduler.folia;
+
+import ac.grim.grimac.api.plugin.GrimPlugin;
+import ac.grim.grimac.platform.api.scheduler.GlobalRegionScheduler;
+import ac.grim.grimac.platform.api.scheduler.TaskHandle;
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+
+public class FoliaGlobalRegionScheduler implements GlobalRegionScheduler {
+
+    private final io.papermc.paper.threadedregions.scheduler.GlobalRegionScheduler globalRegionScheduler = Bukkit.getGlobalRegionScheduler();
+
+    @Override
+    public void execute(@NotNull GrimPlugin plugin, @NotNull Runnable task) {
+        globalRegionScheduler.execute(GrimACBukkitLoaderPlugin.LOADER, task);
+    }
+
+    @Override
+    public TaskHandle run(@NotNull GrimPlugin plugin, @NotNull Runnable task) {
+        return new FoliaTaskHandle(globalRegionScheduler.run(GrimACBukkitLoaderPlugin.LOADER, ignored -> task.run()));
+    }
+
+    @Override
+    public TaskHandle runDelayed(@NotNull GrimPlugin plugin, @NotNull Runnable task, long delay) {
+        return new FoliaTaskHandle(globalRegionScheduler.runDelayed(GrimACBukkitLoaderPlugin.LOADER, ignored -> task.run(), delay));
+    }
+
+    @Override
+    public TaskHandle runAtFixedRate(@NotNull GrimPlugin plugin, @NotNull Runnable task, long initialDelayTicks, long periodTicks) {
+        return new FoliaTaskHandle(globalRegionScheduler.runAtFixedRate(GrimACBukkitLoaderPlugin.LOADER, ignored -> task.run(), initialDelayTicks, periodTicks));
+    }
+
+    @Override
+    public void cancel(@NotNull GrimPlugin plugin) {
+        globalRegionScheduler.cancelTasks(GrimACBukkitLoaderPlugin.LOADER);
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/scheduler/folia/FoliaPlatformScheduler.java

@@ -0,0 +1,13 @@
+package ac.grim.grimac.platform.bukkit.scheduler.folia;
+
+import ac.grim.grimac.platform.api.scheduler.PlatformScheduler;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+@Getter
+public class FoliaPlatformScheduler implements PlatformScheduler {
+    private final @NotNull FoliaAsyncScheduler asyncScheduler = new FoliaAsyncScheduler();
+    private final @NotNull FoliaGlobalRegionScheduler globalRegionScheduler = new FoliaGlobalRegionScheduler();
+    private final @NotNull FoliaEntityScheduler entityScheduler = new FoliaEntityScheduler();
+    private final @NotNull FoliaRegionScheduler regionScheduler = new FoliaRegionScheduler();
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/scheduler/folia/FoliaRegionScheduler.java

@@ -0,0 +1,85 @@
+package ac.grim.grimac.platform.bukkit.scheduler.folia;
+
+import ac.grim.grimac.api.plugin.GrimPlugin;
+import ac.grim.grimac.platform.api.scheduler.RegionScheduler;
+import ac.grim.grimac.platform.api.scheduler.TaskHandle;
+import ac.grim.grimac.platform.api.world.PlatformWorld;
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import ac.grim.grimac.platform.bukkit.world.BukkitPlatformWorld;
+import ac.grim.grimac.utils.math.Location;
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+
+public class FoliaRegionScheduler implements RegionScheduler {
+
+    private final io.papermc.paper.threadedregions.scheduler.RegionScheduler regionScheduler = Bukkit.getRegionScheduler();
+
+    @Override
+    public void execute(@NotNull GrimPlugin plugin, @NotNull PlatformWorld world, int chunkX, int chunkZ, @NotNull Runnable task) {
+        regionScheduler.execute(GrimACBukkitLoaderPlugin.LOADER, ((BukkitPlatformWorld) world).getBukkitWorld(), chunkX, chunkZ, task);
+    }
+
+    @Override
+    public void execute(@NotNull GrimPlugin plugin, @NotNull Location location, @NotNull Runnable task) {
+        execute(plugin, location.getWorld(), location.getBlockX() >> 4, location.getBlockZ() >> 4, task);
+    }
+
+    @Override
+    public TaskHandle run(@NotNull GrimPlugin plugin, @NotNull PlatformWorld world, int chunkX, int chunkZ, @NotNull Runnable task) {
+        return new FoliaTaskHandle(regionScheduler.run(
+                GrimACBukkitLoaderPlugin.LOADER,
+                ((BukkitPlatformWorld) world).getBukkitWorld(),
+                chunkX,
+                chunkZ,
+                ignored -> task.run()
+        ));
+    }
+
+    @Override
+    public TaskHandle run(@NotNull GrimPlugin plugin, @NotNull Location location, @NotNull Runnable task) {
+        return run(plugin, location.getWorld(), location.getBlockX() >> 4, location.getBlockZ() >> 4, task);
+    }
+
+    @Override
+    public TaskHandle runDelayed(@NotNull GrimPlugin plugin, @NotNull PlatformWorld world, int chunkX, int chunkZ, @NotNull Runnable task, long delayTicks) {
+        return new FoliaTaskHandle(regionScheduler.runDelayed(
+                GrimACBukkitLoaderPlugin.LOADER,
+                ((BukkitPlatformWorld) world).getBukkitWorld(),
+                chunkX,
+                chunkZ,
+                ignored -> task.run(),
+                delayTicks
+        ));
+    }
+
+    @Override
+    public TaskHandle runDelayed(@NotNull GrimPlugin plugin, @NotNull Location location, @NotNull Runnable task, long delayTicks) {
+        return runDelayed(plugin, location.getWorld(), location.getBlockX() >> 4, location.getBlockZ() >> 4, task, delayTicks);
+    }
+
+    @Override
+    public TaskHandle runAtFixedRate(@NotNull GrimPlugin plugin, @NotNull PlatformWorld world, int chunkX, int chunkZ, @NotNull Runnable task, long initialDelayTicks, long periodTicks) {
+        return new FoliaTaskHandle(regionScheduler.runAtFixedRate(
+                GrimACBukkitLoaderPlugin.LOADER,
+                ((BukkitPlatformWorld) world).getBukkitWorld(),
+                chunkX,
+                chunkZ,
+                ignored -> task.run(),
+                initialDelayTicks,
+                periodTicks
+        ));
+    }
+
+    @Override
+    public TaskHandle runAtFixedRate(@NotNull GrimPlugin plugin, @NotNull Location location, @NotNull Runnable task, long initialDelayTicks, long periodTicks) {
+        return runAtFixedRate(
+                plugin,
+                location.getWorld(),
+                location.getBlockX() >> 4,
+                location.getBlockZ() >> 4,
+                task,
+                initialDelayTicks,
+                periodTicks
+        );
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/scheduler/folia/FoliaTaskHandle.java

@@ -0,0 +1,33 @@
+package ac.grim.grimac.platform.bukkit.scheduler.folia;
+
+import ac.grim.grimac.platform.api.scheduler.TaskHandle;
+import io.papermc.paper.threadedregions.scheduler.ScheduledTask;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class FoliaTaskHandle implements TaskHandle {
+
+    private final @NotNull ScheduledTask task;
+
+    @Contract(pure = true)
+    public FoliaTaskHandle(@NotNull ScheduledTask task) {
+        this.task = Objects.requireNonNull(task);
+    }
+
+    @Override
+    public boolean isSync() {
+        return false;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return task.isCancelled();
+    }
+
+    @Override
+    public void cancel() {
+        task.cancel();
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/sender/BukkitSenderFactory.java

@@ -0,0 +1,89 @@
+package ac.grim.grimac.platform.bukkit.sender;
+
+import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.platform.api.sender.Sender;
+import ac.grim.grimac.platform.api.sender.SenderFactory;
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import net.kyori.adventure.platform.bukkit.BukkitAudiences;
+import net.kyori.adventure.text.Component;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.command.RemoteConsoleCommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.permissions.Permission;
+import org.bukkit.permissions.PermissionDefault;
+import org.incendo.cloud.SenderMapper;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.UUID;
+
+public class BukkitSenderFactory extends SenderFactory<CommandSender> implements SenderMapper<CommandSender, Sender> {
+    private final BukkitAudiences audiences;
+
+    public BukkitSenderFactory() {
+        this.audiences = BukkitAudiences.create(GrimACBukkitLoaderPlugin.LOADER);
+    }
+
+    @Override
+    protected String getName(CommandSender sender) {
+        return sender instanceof Player ? sender.getName() : Sender.CONSOLE_NAME;
+    }
+
+    @Override
+    protected UUID getUniqueId(CommandSender sender) {
+        return sender instanceof Player player ? player.getUniqueId() : Sender.CONSOLE_UUID;
+    }
+
+    @Override
+    protected void sendMessage(CommandSender sender, String message) {
+        sender.sendMessage(message);
+    }
+
+    @Override
+    protected void sendMessage(CommandSender sender, Component message) {
+        // we can safely send async for players and the console - otherwise, send it sync
+        if (sender instanceof Player || sender instanceof ConsoleCommandSender || sender instanceof RemoteConsoleCommandSender) {
+            this.audiences.sender(sender).sendMessage(message);
+        } else {
+            GrimAPI.INSTANCE.getScheduler().getGlobalRegionScheduler().run(
+                    GrimAPI.INSTANCE.getGrimPlugin(),
+                    () -> this.audiences.sender(sender).sendMessage(message)
+            );
+        }
+    }
+
+    @Override
+    protected boolean hasPermission(CommandSender sender, String node) {
+        return sender.hasPermission(node);
+    }
+
+    @Override
+    protected boolean hasPermission(CommandSender sender, String node, boolean defaultIfUnset) {
+        return sender.hasPermission(new Permission(node, defaultIfUnset ? PermissionDefault.TRUE : PermissionDefault.FALSE));
+    }
+
+    @Override
+    protected void performCommand(CommandSender sender, String command) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    protected boolean isConsole(CommandSender sender) {
+        return sender instanceof ConsoleCommandSender || sender instanceof RemoteConsoleCommandSender;
+    }
+
+    @Override
+    protected boolean isPlayer(CommandSender sender) {
+        return sender instanceof Player;
+    }
+
+    @Override
+    public @NotNull Sender map(@NotNull CommandSender base) {
+        return this.wrap(base);
+    }
+
+    @Override
+    public @NotNull CommandSender reverse(@NotNull Sender mapped) {
+        return this.unwrap(mapped);
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/utils/anticheat/MultiLibUtil.java

@@ -0,0 +1,26 @@
+package ac.grim.grimac.platform.bukkit.utils.anticheat;
+
+import ac.grim.grimac.utils.anticheat.LogUtil;
+import ac.grim.grimac.utils.reflection.ReflectionUtils;
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.Method;
+
+public class MultiLibUtil {
+
+    public final static Method externalPlayerMethod = ReflectionUtils.getMethod(Player.class, "isExternalPlayer");
+    private static final boolean IS_PRE_1_18 = PacketEvents.getAPI().getServerManager().getVersion().isOlderThan(ServerVersion.V_1_18);
+
+    // TODO: cache external players for better performance, but this only matters for people using multi-lib
+    public static boolean isExternalPlayer(Player player) {
+        if (externalPlayerMethod == null || IS_PRE_1_18) return false;
+        try {
+            return (boolean) externalPlayerMethod.invoke(player);
+        } catch (Exception e) {
+            LogUtil.error("Failed to invoke external player method", e);
+            return false;
+        }
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/utils/convert/BukkitConversionUtils.java

@@ -0,0 +1,45 @@
+package ac.grim.grimac.platform.bukkit.utils.convert;
+
+import ac.grim.grimac.platform.api.permissions.PermissionDefaultValue;
+import ac.grim.grimac.platform.bukkit.world.BukkitPlatformWorld;
+import ac.grim.grimac.utils.math.Location;
+import com.github.retrooper.packetevents.protocol.world.BlockFace;
+import org.bukkit.permissions.PermissionDefault;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Nullable;
+
+public class BukkitConversionUtils {
+    @Contract("null -> null; !null -> new")
+    public static org.bukkit.Location toBukkitLocation(Location location) {
+        if (location == null) return null;
+        return new org.bukkit.Location(((BukkitPlatformWorld) location.getWorld()).getBukkitWorld(), location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
+    }
+
+    /**
+     * Converts this enum to a Bukkit PermissionDefault.
+     *
+     * @return The corresponding Bukkit PermissionDefault.
+     */
+    @Contract(value = "null -> null; !null -> !null", pure = true)
+    public static @Nullable PermissionDefault toBukkitPermissionDefault(@Nullable PermissionDefaultValue permissionDefaultValue) {
+        if (permissionDefaultValue == null) return null;
+        return switch (permissionDefaultValue) {
+            case TRUE -> PermissionDefault.TRUE;
+            case FALSE -> PermissionDefault.FALSE;
+            case OP -> PermissionDefault.OP;
+            case NOT_OP -> PermissionDefault.NOT_OP;
+        };
+    }
+
+    public static BlockFace fromBukkitFace(org.bukkit.block.BlockFace face) {
+        return switch (face) {
+            case NORTH -> BlockFace.NORTH;
+            case SOUTH -> BlockFace.SOUTH;
+            case WEST -> BlockFace.WEST;
+            case EAST -> BlockFace.EAST;
+            case UP -> BlockFace.UP;
+            case DOWN -> BlockFace.DOWN;
+            default -> BlockFace.OTHER;
+        };
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/utils/placeholder/PlaceholderAPIExpansion.java

@@ -0,0 +1,79 @@
+package ac.grim.grimac.platform.bukkit.utils.placeholder;
+
+import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.api.GrimUser;
+import ac.grim.grimac.player.GrimPlayer;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+
+public class PlaceholderAPIExpansion extends PlaceholderExpansion {
+
+    @Override
+    public @NotNull String getIdentifier() {
+        return "grim";
+    }
+
+    public @NotNull String getAuthor() {
+        return String.join(", ", GrimAPI.INSTANCE.getGrimPlugin().getDescription().getAuthors());
+    }
+
+    @Override
+    public @NotNull String getVersion() {
+        return GrimAPI.INSTANCE.getExternalAPI().getGrimVersion();
+    }
+
+    @Override
+    public boolean persist() {
+        return true;
+    }
+
+    @Override
+    public @NotNull List<String> getPlaceholders() {
+        Set<String> staticReplacements = GrimAPI.INSTANCE.getExternalAPI().getStaticReplacements().keySet();
+        Set<String> variableReplacements = GrimAPI.INSTANCE.getExternalAPI().getVariableReplacements().keySet();
+        ArrayList<String> placeholders = new ArrayList<>(staticReplacements.size() + variableReplacements.size());
+        for (String s : staticReplacements) {
+            placeholders.add(s.equals("%grim_version%") ? s : "%grim_" + s.replaceAll("%", "") + "%");
+        }
+        for (String s : variableReplacements) {
+            placeholders.add(s.equals("%player%") ? "%grim_player%" : "%grim_player_" + s.replaceAll("%", "") + "%");
+        }
+        return placeholders;
+    }
+
+    @Override
+    public String onRequest(OfflinePlayer offlinePlayer, @NotNull String params) {
+        for (Map.Entry<String, String> entry : GrimAPI.INSTANCE.getExternalAPI().getStaticReplacements().entrySet()) {
+            String key = entry.getKey().equals("%grim_version%")
+                    ? "version"
+                    : entry.getKey().replaceAll("%", "");
+            if (params.equalsIgnoreCase(key)) {
+                return entry.getValue();
+            }
+        }
+
+        if (offlinePlayer instanceof Player player) {
+            GrimPlayer grimPlayer = GrimAPI.INSTANCE.getPlayerDataManager().getPlayer(player.getUniqueId());
+            if (grimPlayer == null) return null;
+
+            for (Map.Entry<String, Function<GrimUser, String>> entry : GrimAPI.INSTANCE.getExternalAPI().getVariableReplacements().entrySet()) {
+                String key = entry.getKey().equals("%player%")
+                        ? "player"
+                        : "player_" + entry.getKey().replaceAll("%", "");
+                if (params.equalsIgnoreCase(key)) {
+                    return entry.getValue().apply(grimPlayer);
+                }
+            }
+        }
+
+        return null;
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/utils/reflection/PaperUtils.java

@@ -0,0 +1,40 @@
+package ac.grim.grimac.platform.bukkit.utils.reflection;
+
+import ac.grim.grimac.platform.bukkit.GrimACBukkitLoaderPlugin;
+import ac.grim.grimac.utils.anticheat.LogUtil;
+import ac.grim.grimac.utils.reflection.ReflectionUtils;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.event.Event;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+import java.util.concurrent.CompletableFuture;
+
+public class PaperUtils {
+    public static final boolean PAPER = ReflectionUtils.hasClass("com.destroystokyo.paper.PaperConfig")
+            || ReflectionUtils.hasClass("io.papermc.paper.configuration.Configuration");
+
+    public static CompletableFuture<Boolean> teleportAsync(final Entity entity, final Location location) {
+        return PAPER ? entity.teleportAsync(location) : CompletableFuture.completedFuture(entity.teleport(location));
+    }
+
+    @SuppressWarnings("unchecked")
+    public static boolean registerTickEndEvent(Listener listener, Runnable runnable) {
+        try {
+            Class<?> clazz = ReflectionUtils.getClass("com.destroystokyo.paper.event.server.ServerTickEndEvent");
+            if (clazz == null) return false;
+            GrimACBukkitLoaderPlugin.LOADER.getServer().getPluginManager().registerEvent(
+                    (Class<? extends Event>) clazz,
+                    listener,
+                    EventPriority.NORMAL,
+                    (l, event) -> runnable.run(),
+                    GrimACBukkitLoaderPlugin.LOADER
+            );
+            return true;
+        } catch (Exception e) {
+            LogUtil.error("Failed to register tick end event", e);
+        }
+        return false;
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/world/BukkitPlatformChunk.java

@@ -0,0 +1,38 @@
+package ac.grim.grimac.platform.bukkit.world;
+
+import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.platform.api.Platform;
+import ac.grim.grimac.platform.api.world.PlatformChunk;
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
+import com.github.retrooper.packetevents.protocol.world.states.WrappedBlockState;
+import lombok.RequiredArgsConstructor;
+import org.bukkit.Chunk;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@RequiredArgsConstructor
+public class BukkitPlatformChunk implements PlatformChunk {
+    private static final Map<BlockData, Integer> blockDataToId = GrimAPI.INSTANCE.getPlatform() == Platform.FOLIA ? new ConcurrentHashMap<>() : new HashMap<>();
+    private static final boolean isFlat = PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_13);
+    private final @NotNull Chunk chunk;
+
+    @Override
+    public int getBlockID(int x, int y, int z) {
+        Block block = chunk.getBlock(x, y, z);
+
+        return isFlat // Cache blockDataToID because Strings are expensive
+                ? blockDataToId.computeIfAbsent(block.getBlockData(), data -> WrappedBlockState.getByString(PacketEvents.getAPI().getServerManager().getVersion().toClientVersion(), data.getAsString(false)).getGlobalId())
+                : getLegacyBlockID(block);
+    }
+
+    @SuppressWarnings({ "deprecation", "UnstableApiUsage" })
+    private static int getLegacyBlockID(@NotNull Block block) {
+        return (block.getType().getId() << 4) | block.getData();
+    }
+}

bukkit/src/main/java/ac/grim/grimac/platform/bukkit/world/BukkitPlatformWorld.java

@@ -0,0 +1,62 @@
+package ac.grim.grimac.platform.bukkit.world;
+
+import ac.grim.grimac.platform.api.world.PlatformChunk;
+import ac.grim.grimac.platform.api.world.PlatformWorld;
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
+import com.github.retrooper.packetevents.protocol.world.states.WrappedBlockState;
+import io.github.retrooper.packetevents.util.SpigotConversionUtil;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+@Getter
+@RequiredArgsConstructor
+public class BukkitPlatformWorld implements PlatformWorld {
+
+    private static final boolean LEGACY_SERVER_VERSION = PacketEvents.getAPI().getServerManager().getVersion().isOlderThanOrEquals(ServerVersion.V_1_12_2);
+    private final @NotNull World bukkitWorld;
+
+    @Override
+    public boolean isChunkLoaded(int chunkX, int chunkZ) {
+        return bukkitWorld.isChunkLoaded(chunkX, chunkZ);
+    }
+
+    @Override
+    public WrappedBlockState getBlockAt(int x, int y, int z) {
+        if (LEGACY_SERVER_VERSION) {
+            Block block = bukkitWorld.getBlockAt(x, y, z);
+            @SuppressWarnings({"deprecation", "UnstableApiUsage"})
+            int blockId = (block.getType().getId() << 4) | block.getData();
+            return WrappedBlockState.getByGlobalId(blockId);
+        } else {
+            return SpigotConversionUtil.fromBukkitBlockData(bukkitWorld.getBlockAt(x, y, z).getBlockData());
+        }
+    }
+
+    @Override
+    public String getName() {
+        return bukkitWorld.getName();
+    }
+
+    @Override
+    public @Nullable UUID getUID() {
+        return this.bukkitWorld.getUID();
+    }
+
+    @Override
+    public PlatformChunk getChunkAt(int currChunkX, int currChunkZ) {
+        return new BukkitPlatformChunk(bukkitWorld.getChunkAt(currChunkX, currChunkZ));
+    }
+
+    @Override
+    public boolean isLoaded() {
+        return Bukkit.getWorld(bukkitWorld.getUID()) != null;
+    }
+}

cliff.toml

@@ -0,0 +1,47 @@
+# cliff.toml - DEV BUILDS - Now with Author Info
+
+[changelog]
+body = """
+## Changes in this Build (since previous push)
+{%- for group, commits in commits | group_by(attribute="group") %}
+    ### {{ group | striptags | upper_first }}
+    {%- for commit in commits %}
+        - {{ commit.message | upper_first }} - *by {{ commit.author.name }}* {% if commit.breaking %}**[BREAKING]**{% endif %} \
+        {%- if commit.remote and commit.remote.url -%}
+            ([`{{ commit.id | truncate(length=7, end="") }}`]({{ commit.remote.url }}/commit/{{- commit.id -}}))
+        {%- else -%}
+            (`{{ commit.id | truncate(length=7, end="") }}`)
+        {%- endif -%}
+    {% endfor %}
+{% endfor %}
+"""
+trim = true
+
+[git]
+# Your previous settings here are perfect, no changes needed
+filter_unconventional = false
+skip_unconventional = false
+remote = "https://github.com/GrimAnticheat/Grim"
+commit_parsers = [
+    { message = "^feat", group = "🚀 Features" },
+    { message = "^fix", group = "🐛 Fixes" },
+    { message = "^perf", group = "⚡️ Performance" },
+    { message = "^refactor", group = "♻️ Refactoring" },
+    { message = "^docs", group = "📖 Documentation" },
+    { message = "^test", group = "✅ Tests" },
+    { message = "^chore", group = "🤖 Maintenance & CI" },
+    { body = ".*BREAKING CHANGE.*", group = "🚨 Breaking Changes" },
+    { message = ".*", group = "Miscellaneous" } # CHANGED THIS LINE
+]
+commit_preprocessors = [
+    { pattern = 'src/main/java/ac/grim/grimac/checks/.*', group = "✔️ Checks" },
+    { pattern = 'src/main/java/ac/grim/grimac/api/.*', group = "🔌 API" },
+    { pattern = 'src/main/java/ac/grim/grimac/platform/.*', group = "🏗️ Platform" },
+    { pattern = 'src/main/java/ac/grim/grimac/engine/.*', group = "⚙️ Core Engine" },
+    { pattern = 'src/main/java/ac/grim/grimac/config/.*', group = "⚙️ Configuration" },
+    { pattern = 'pom.xml', group = "🤖 Maintenance & CI" },
+    { pattern = '.github/.*', group = "🤖 Maintenance & CI" },
+    { pattern = 'build.gradle.kts', group = "🤖 Maintenance & CI" },
+    { pattern = 'src/.*', group = "⚙️ Core Engine" },
+]
+sort_commits = "oldest"

common/build.gradle.kts

@@ -0,0 +1,107 @@
+import versioning.BuildConfig
+
+plugins {
+    `maven-publish`
+    grim.`base-conventions`
+}
+
+repositories {
+    if (BuildConfig.mavenLocalOverride) {
+        mavenLocal()
+    }
+
+    exclusiveContent {
+        forRepository {
+            maven("https://repo.grim.ac/snapshots") // Grim API
+        }
+        filter {
+            includeGroup("ac.grim.grimac")
+            includeGroup("com.github.retrooper")
+        }
+    }
+
+    exclusiveContent {
+        forRepository {
+            maven("https://repo.viaversion.com") { // ViaVersion
+                mavenContent { releasesOnly() }
+            }
+        }
+        filter {
+            includeGroup("com.viaversion")
+        }
+    }
+
+    exclusiveContent {
+        forRepository {
+            maven("https://nexus.scarsz.me/content/repositories/releases") { // Configuralize
+                mavenContent { releasesOnly() }
+            }
+        }
+        filter {
+            includeGroup("github.scarsz")
+        }
+    }
+
+    exclusiveContent {
+        forRepository {
+            maven("https://repo.opencollab.dev/maven-releases/") { // Cumulus (for Floodgate)
+                mavenContent { releasesOnly() }
+            }
+        }
+        filter {
+            includeGroup("org.geysermc.api")
+        }
+    }
+
+    exclusiveContent {
+        forRepository {
+            maven("https://repo.opencollab.dev/maven-snapshots/") { // Floodgate
+                mavenContent { snapshotsOnly() }
+            }
+        }
+        filter {
+            includeGroup("org.geysermc.floodgate")
+            includeGroup("org.geysermc.cumulus")
+            includeModule("org.geysermc", "common")
+            includeModule("org.geysermc", "geyser-parent")
+        }
+    }
+
+    mavenCentral()
+}
+
+dependencies {
+    if (BuildConfig.shadePE) {
+        api(libs.packetevents.api)
+    } else {
+        compileOnly(libs.packetevents.api)
+    }
+    api(libs.cloud.core)
+    api(libs.cloud.processors.requirements)
+    api(libs.configuralize) {
+        artifact {
+            classifier = "slim"
+        }
+        exclude(group = "org.yaml", module = "snakeyaml")
+    }
+    // Bump snakeyaml (transitive dep of configuralize) 1.29 -> 2.2+ for geyser-fabric
+    api(libs.snakeyaml)
+    api(libs.fastutil)
+    api(libs.adventure.text.minimessage)
+    api(libs.jetbrains.annotations)
+    api(libs.hikaricp)
+
+    api(libs.grim.api)
+
+    compileOnly(libs.geyser.base.api) {
+        isTransitive = false // messes with guava otherwise
+    }
+
+    compileOnly(libs.floodgate.api)
+    compileOnly(libs.viaversion)
+    compileOnly(libs.netty)
+}
+
+publishing.publications.create<MavenPublication>("maven") {
+    from(components["java"])
+}

common/src/main/java/ac/grim/grimac/GrimAPI.java

@@ -0,0 +1,149 @@
+package ac.grim.grimac;
+
+import ac.grim.grimac.api.event.EventBus;
+import ac.grim.grimac.api.plugin.GrimPlugin;
+import ac.grim.grimac.events.GrimExtensionManager;
+import ac.grim.grimac.events.OptimizedEventBus;
+import ac.grim.grimac.manager.AlertManagerImpl;
+import ac.grim.grimac.manager.DiscordManager;
+import ac.grim.grimac.manager.InitManager;
+import ac.grim.grimac.manager.SpectateManager;
+import ac.grim.grimac.manager.TickManager;
+import ac.grim.grimac.manager.config.BaseConfigManager;
+import ac.grim.grimac.manager.init.Initable;
+import ac.grim.grimac.manager.violationdatabase.ViolationDatabaseManager;
+import ac.grim.grimac.platform.api.Platform;
+import ac.grim.grimac.platform.api.PlatformLoader;
+import ac.grim.grimac.platform.api.PlatformServer;
+import ac.grim.grimac.platform.api.manager.ItemResetHandler;
+import ac.grim.grimac.platform.api.manager.MessagePlaceHolderManager;
+import ac.grim.grimac.platform.api.manager.CommandAdapter;
+import ac.grim.grimac.platform.api.manager.PermissionRegistrationManager;
+import ac.grim.grimac.platform.api.manager.PlatformPluginManager;
+import ac.grim.grimac.platform.api.player.PlatformPlayerFactory;
+import ac.grim.grimac.platform.api.scheduler.PlatformScheduler;
+import ac.grim.grimac.platform.api.sender.Sender;
+import ac.grim.grimac.platform.api.sender.SenderFactory;
+import ac.grim.grimac.utils.anticheat.PlayerDataManager;
+import ac.grim.grimac.utils.common.arguments.CommonGrimArguments;
+import ac.grim.grimac.utils.reflection.ReflectionUtils;
+import lombok.Getter;
+import org.incendo.cloud.CommandManager;
+import org.jetbrains.annotations.NotNull;
+
+
+@Getter
+public final class GrimAPI {
+    public static final GrimAPI INSTANCE = new GrimAPI();
+
+    @Getter
+    private final Platform platform = detectPlatform();
+    private final BaseConfigManager configManager;
+    private final AlertManagerImpl alertManager;
+    private final SpectateManager spectateManager;
+    private final DiscordManager discordManager;
+    private final PlayerDataManager playerDataManager;
+    private final TickManager tickManager;
+    private final GrimExtensionManager extensionManager;
+    private final EventBus eventBus;
+    private final GrimExternalAPI externalAPI;
+    private ViolationDatabaseManager violationDatabaseManager;
+    private PlatformLoader loader;
+    @Getter
+    private InitManager initManager;
+    private boolean initialized = false;
+
+    private GrimAPI() {
+        this.configManager = new BaseConfigManager();
+        this.alertManager = new AlertManagerImpl();
+        this.spectateManager = new SpectateManager();
+        this.discordManager = new DiscordManager();
+        this.playerDataManager = new PlayerDataManager();
+        this.tickManager = new TickManager();
+        this.extensionManager = new GrimExtensionManager();
+        this.eventBus = new OptimizedEventBus(extensionManager);
+        this.externalAPI = new GrimExternalAPI(this);
+    }
+
+    // the order matters
+    private static Platform detectPlatform() {
+        Platform override = CommonGrimArguments.PLATFORM_OVERRIDE.value();
+        if (override != null) return override;
+        if (ReflectionUtils.hasClass("io.papermc.paper.threadedregions.RegionizedServer")) return Platform.FOLIA;
+        if (ReflectionUtils.hasClass("org.bukkit.Bukkit")) return Platform.BUKKIT;
+        if (ReflectionUtils.hasClass("net.fabricmc.loader.api.FabricLoader")) return Platform.FABRIC;
+        throw new IllegalStateException("Unknown platform!");
+    }
+
+    public void load(PlatformLoader platformLoader, Initable... platformSpecificInitables) {
+        this.loader = platformLoader;
+        this.violationDatabaseManager = new ViolationDatabaseManager(getGrimPlugin());
+        this.initManager = new InitManager(loader.getPacketEvents(), loader::getCommandManager, platformSpecificInitables);
+        this.initManager.load();
+        this.initialized = true;
+    }
+
+    public void start() {
+        checkInitialized();
+        initManager.start();
+    }
+
+    public void stop() {
+        checkInitialized();
+        initManager.stop();
+    }
+
+    public PlatformScheduler getScheduler() {
+        return loader.getScheduler();
+    }
+
+    public PlatformPlayerFactory getPlatformPlayerFactory() {
+        return loader.getPlatformPlayerFactory();
+    }
+
+    public CommandAdapter getCommandAdapter() {
+        return loader.getCommandAdapter();
+    }
+
+    public GrimPlugin getGrimPlugin() {
+        return loader.getPlugin();
+    }
+
+    public SenderFactory<?> getSenderFactory() {
+        return loader.getSenderFactory();
+    }
+
+    public ItemResetHandler getItemResetHandler() {
+        return loader.getItemResetHandler();
+    }
+
+    public PlatformPluginManager getPluginManager() {
+        return loader.getPluginManager();
+    }
+
+    public PlatformServer getPlatformServer() {
+        return loader.getPlatformServer();
+    }
+
+    public @NotNull MessagePlaceHolderManager getMessagePlaceHolderManager() {
+        return loader.getMessagePlaceHolderManager();
+    }
+
+    public CommandManager<Sender> getCommandManager() {
+        return loader.getCommandManager();
+    }
+
+    private void checkInitialized() {
+        if (!initialized) {
+            throw new IllegalStateException("GrimAPI has not been initialized!");
+        }
+    }
+
+    public PermissionRegistrationManager getPermissionManager() {
+        return loader.getPermissionManager();
+    }
+
+    public GrimExtensionManager getExtensionManager() {
+        return extensionManager;
+    }
+}

common/src/main/java/ac/grim/grimac/GrimExternalAPI.java

@@ -4,64 +4,50 @@ import ac.grim.grimac.api.GrimAbstractAPI;
 import ac.grim.grimac.api.GrimUser;
 import ac.grim.grimac.api.alerts.AlertManager;
 import ac.grim.grimac.api.config.ConfigManager;
-import ac.grim.grimac.api.events.GrimReloadEvent;
+import ac.grim.grimac.api.event.EventBus;
+import ac.grim.grimac.api.event.events.GrimReloadEvent;
 import ac.grim.grimac.manager.config.ConfigManagerFileImpl;
-import ac.grim.grimac.manager.init.Initable;
+import ac.grim.grimac.manager.init.start.StartableInitable;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.LogUtil;
+import ac.grim.grimac.utils.anticheat.MessageUtil;
 import ac.grim.grimac.utils.common.ConfigReloadObserver;
-import com.github.retrooper.packetevents.netty.channel.ChannelHelper;
-import io.github.retrooper.packetevents.util.SpigotReflectionUtil;
-import io.github.retrooper.packetevents.util.folia.FoliaScheduler;
 import lombok.Getter;
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.PluginDescriptionFile;
-import org.bukkit.plugin.ServicePriority;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Map;
+import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 
 //This is used for grim's external API. It has its own class just for organization.
 
-public class GrimExternalAPI implements GrimAbstractAPI, ConfigReloadObserver, Initable {
+public class GrimExternalAPI implements GrimAbstractAPI, ConfigReloadObserver, StartableInitable {
 
     private final GrimAPI api;
+    @Getter
+    private final Map<String, Function<GrimUser, String>> variableReplacements = new ConcurrentHashMap<>();
+    @Getter
+    private final Map<String, String> staticReplacements = new ConcurrentHashMap<>();
+    private final Map<String, Function<Object, Object>> functions = new ConcurrentHashMap<>();
+    private final ConfigManagerFileImpl configManagerFile = new ConfigManagerFileImpl();
+    private ConfigManager configManager = null;
+    private boolean started = false;
 
     public GrimExternalAPI(GrimAPI api) {
         this.api = api;
     }
 
-    @Nullable
     @Override
-    public GrimUser getGrimUser(Player player) {
-        return api.getPlayerDataManager().getPlayer(player);
+    public @NotNull EventBus getEventBus() {
+        return api.getEventBus();
     }
 
     @Override
-    public void setServerName(String name) {
-        variableReplacements.put("%server%", user -> name);
-    }
-
-    @Getter
-    private final Map<String, Function<GrimUser, String>> variableReplacements = new ConcurrentHashMap<>();
-
-    @Getter
-    private final Map<String, String> staticReplacements = new ConcurrentHashMap<>();
-
-    public String replaceVariables(GrimUser user, String content, boolean colors) {
-        if (colors) content = ChatColor.translateAlternateColorCodes('&', content);
-        for (Map.Entry<String, String> entry : staticReplacements.entrySet()) {
-            content = content.replace(entry.getKey(), entry.getValue());
-        }
-        for (Map.Entry<String, Function<GrimUser, String>> entry : variableReplacements.entrySet()) {
-            content = content.replace(entry.getKey(), entry.getValue().apply(user));
-        }
-        return content;
+    public @Nullable GrimUser getGrimUser(UUID uuid) {
+        return api.getPlayerDataManager().getPlayer(uuid);
     }
 
     @Override
@@ -84,12 +70,9 @@ public class GrimExternalAPI implements GrimAbstractAPI, ConfigReloadObserver, I
 
     @Override
     public String getGrimVersion() {
-        PluginDescriptionFile description = GrimAPI.INSTANCE.getPlugin().getDescription();
-        return description.getVersion();
+        return api.getGrimPlugin().getDescription().getVersion();
     }
 
-    private final Map<String, Function<Object, Object>> functions = new ConcurrentHashMap<>();
-
     @Override
     public void registerFunction(String key, Function<Object, Object> function) {
         if (function == null) {
@@ -114,14 +97,20 @@ public class GrimExternalAPI implements GrimAbstractAPI, ConfigReloadObserver, I
         return configManager;
     }
 
-    private ConfigManager configManager = null;
-    private final ConfigManagerFileImpl configManagerFile = new ConfigManagerFileImpl();
-    private boolean started = false;
+    @Override
+    public boolean hasStarted() {
+        return started;
+    }
+
+    @Override
+    public int getCurrentTick() {
+        return GrimAPI.INSTANCE.getTickManager().currentTick;
+    }
 
     // on load, load the config & register the service
     public void load() {
         reload(configManagerFile);
-        Bukkit.getServicesManager().register(GrimAbstractAPI.class, this, GrimAPI.INSTANCE.getPlugin(), ServicePriority.Normal);
+        api.getLoader().registerAPIService();
     }
 
     // handles any config loading that's needed to be done after load
@@ -131,15 +120,15 @@ public class GrimExternalAPI implements GrimAbstractAPI, ConfigReloadObserver, I
         try {
             GrimAPI.INSTANCE.getConfigManager().start();
         } catch (Exception e) {
-            e.printStackTrace();
+            LogUtil.error("Failed to start config manager.", e);
         }
     }
 
     @Override
     public void reload(ConfigManager config) {
         if (config.isLoadedAsync() && started) {
-            FoliaScheduler.getAsyncScheduler().runNow(GrimAPI.INSTANCE.getPlugin(),
-                    o -> successfulReload(config));
+            GrimAPI.INSTANCE.getScheduler().getAsyncScheduler().runNow(GrimAPI.INSTANCE.getGrimPlugin(),
+                    () -> successfulReload(config));
         } else {
             successfulReload(config);
         }
@@ -149,8 +138,8 @@ public class GrimExternalAPI implements GrimAbstractAPI, ConfigReloadObserver, I
     public CompletableFuture<Boolean> reloadAsync(ConfigManager config) {
         if (config.isLoadedAsync() && started) {
             CompletableFuture<Boolean> future = new CompletableFuture<>();
-            FoliaScheduler.getAsyncScheduler().runNow(GrimAPI.INSTANCE.getPlugin(),
-                    o -> future.complete(successfulReload(config)));
+            GrimAPI.INSTANCE.getScheduler().getAsyncScheduler().runNow(GrimAPI.INSTANCE.getGrimPlugin(),
+                    () -> future.complete(successfulReload(config)));
             return future;
         }
         return CompletableFuture.completedFuture(successfulReload(config));
@@ -162,14 +151,16 @@ public class GrimExternalAPI implements GrimAbstractAPI, ConfigReloadObserver, I
             GrimAPI.INSTANCE.getConfigManager().load(config);
             if (started) GrimAPI.INSTANCE.getConfigManager().start();
             onReload(config);
-            if (started) FoliaScheduler.getAsyncScheduler().runNow(GrimAPI.INSTANCE.getPlugin(),
-                    o -> Bukkit.getPluginManager().callEvent(new GrimReloadEvent(true)));
+            if (started)
+                GrimAPI.INSTANCE.getScheduler().getAsyncScheduler().runNow(GrimAPI.INSTANCE.getGrimPlugin(),
+                        () -> GrimAPI.INSTANCE.getEventBus().post(new GrimReloadEvent(true)));
             return true;
         } catch (Exception e) {
-            e.printStackTrace();
+            LogUtil.error("Failed to reload config", e);
         }
-        if (started) FoliaScheduler.getAsyncScheduler().runNow(GrimAPI.INSTANCE.getPlugin(),
-                o -> Bukkit.getPluginManager().callEvent(new GrimReloadEvent(false)));
+        if (started)
+            GrimAPI.INSTANCE.getScheduler().getAsyncScheduler().runNow(GrimAPI.INSTANCE.getGrimPlugin(),
+                    () -> GrimAPI.INSTANCE.getEventBus().post(new GrimReloadEvent(false)));
         return false;
     }
 
@@ -184,16 +175,15 @@ public class GrimExternalAPI implements GrimAbstractAPI, ConfigReloadObserver, I
         // Update variables
         updateVariables();
         // Restart
-        GrimAPI.INSTANCE.getDiscordManager().start();
-        GrimAPI.INSTANCE.getSpectateManager().start();
+        GrimAPI.INSTANCE.getAlertManager().reload(configManager);
+        GrimAPI.INSTANCE.getDiscordManager().reload();
+        GrimAPI.INSTANCE.getSpectateManager().reload();
+        GrimAPI.INSTANCE.getViolationDatabaseManager().reload();
         // Don't reload players if the plugin hasn't started yet
         if (!started) return;
         // Reload checks for all players
-        for (GrimPlayer grimPlayer : GrimAPI.INSTANCE.getPlayerDataManager().getEntries()) {
-            ChannelHelper.runInEventLoop(grimPlayer.user.getChannel(), () -> {
-                grimPlayer.updatePermissions();
-                grimPlayer.reload(configManager);
-            });
+        for (GrimPlayer player : GrimAPI.INSTANCE.getPlayerDataManager().getEntries()) {
+            player.runSafely(() -> player.reload(configManager));
         }
     }
 
@@ -205,11 +195,10 @@ public class GrimExternalAPI implements GrimAbstractAPI, ConfigReloadObserver, I
         variableReplacements.putIfAbsent("%h_sensitivity%", user -> ((int) Math.round(user.getHorizontalSensitivity() * 200)) + "");
         variableReplacements.putIfAbsent("%v_sensitivity%", user -> ((int) Math.round(user.getVerticalSensitivity() * 200)) + "");
         variableReplacements.putIfAbsent("%fast_math%", user -> !user.isVanillaMath() + "");
-        variableReplacements.putIfAbsent("%tps%", user -> String.format("%.2f", SpigotReflectionUtil.getTPS()));
+        variableReplacements.putIfAbsent("%tps%", user -> String.format("%.2f", GrimAPI.INSTANCE.getPlatformServer().getTPS()));
         variableReplacements.putIfAbsent("%version%", GrimUser::getVersionName);
         // static variables
-        staticReplacements.putIfAbsent("%prefix%", ChatColor.translateAlternateColorCodes('&', GrimAPI.INSTANCE.getConfigManager().getPrefix()));
+        staticReplacements.put("%prefix%", MessageUtil.translateAlternateColorCodes('&', GrimAPI.INSTANCE.getConfigManager().getPrefix()));
         staticReplacements.putIfAbsent("%grim_version%", getGrimVersion());
     }
-
 }

common/src/main/java/ac/grim/grimac/checks/Check.java

@@ -0,0 +1,205 @@
+package ac.grim.grimac.checks;
+
+import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.api.AbstractCheck;
+import ac.grim.grimac.api.config.ConfigManager;
+import ac.grim.grimac.api.event.events.FlagEvent;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.packettype.PacketTypeCommon;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import lombok.Getter;
+import lombok.Setter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+import static com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying.isFlying;
+
+// Class from https://github.com/Tecnio/AntiCheatBase/blob/master/src/main/java/me/tecnio/anticheat/check/Check.java
+@Getter
+public class Check extends GrimProcessor implements AbstractCheck {
+    protected @NotNull final GrimPlayer player;
+
+    public double violations;
+    private double decay;
+    private double setbackVL;
+
+    private String checkName;
+    private String configName;
+    private String alternativeName;
+    private String displayName;
+    private String description;
+
+    private boolean experimental;
+    private @Setter boolean isEnabled;
+
+    private boolean exemptPermission;
+    private boolean noSetbackPermission;
+    private boolean noModifyPacketPermission;
+    private long lastViolationTime;
+
+    public Check(final @NotNull GrimPlayer player) {
+        this.player = Objects.requireNonNull(player);
+
+        final CheckData checkData = this.getClass().getAnnotation(CheckData.class);
+        if (checkData != null) {
+            this.checkName = checkData.name();
+            this.configName = checkData.configName();
+            // Fall back to check name
+            if (this.configName.equals("DEFAULT")) this.configName = this.checkName;
+            this.decay = checkData.decay();
+            this.setbackVL = checkData.setback();
+            this.alternativeName = checkData.alternativeName();
+            this.experimental = checkData.experimental();
+            this.description = checkData.description();
+            this.displayName = this.checkName;
+        }
+
+        reload();
+    }
+
+    public boolean shouldModifyPackets() {
+        return isEnabled && !player.disableGrim && !player.noModifyPacketPermission && !exemptPermission;
+    }
+
+    public final void updatePermissions() {
+        if (configName == null || player.platformPlayer == null) return;
+        final String id = configName.toLowerCase();
+        exemptPermission = player.platformPlayer.hasPermission("grim.exempt." + id);
+        noSetbackPermission = player.platformPlayer.hasPermission("grim.nosetback." + id);
+        noModifyPacketPermission = player.platformPlayer.hasPermission("grim.nomodifypacket." + id);
+    }
+
+    public final boolean flagAndAlert(String verbose) {
+        if (flag(verbose)) {
+            alert(verbose);
+            return true;
+        }
+        return false;
+    }
+
+    public final boolean flagAndAlert() {
+        return flagAndAlert("");
+    }
+
+    public final boolean flag() {
+        return flag("");
+    }
+
+    public final boolean flag(String verbose) {
+        if (player.disableGrim || (experimental && !player.isExperimentalChecks()) || exemptPermission)
+            return false; // Avoid calling event if disabled
+
+        FlagEvent event = new FlagEvent(player, this, verbose);
+        GrimAPI.INSTANCE.getEventBus().post(event);
+        if (event.isCancelled()) return false;
+
+        player.punishmentManager.handleViolation(this);
+        lastViolationTime = System.currentTimeMillis();
+        violations++;
+        return true;
+    }
+
+    public final boolean flagWithSetback() {
+        return flagWithSetback("");
+    }
+
+    public final boolean flagWithSetback(String verbose) {
+        if (flag(verbose)) {
+            setbackIfAboveSetbackVL();
+            return true;
+        }
+        return false;
+    }
+
+    public final boolean flagAndAlertWithSetback() {
+        return flagAndAlertWithSetback("");
+    }
+
+    public final boolean flagAndAlertWithSetback(String verbose) {
+        if (flagAndAlert(verbose)) {
+            setbackIfAboveSetbackVL();
+            return true;
+        }
+        return false;
+    }
+
+    public final void reward() {
+        violations = Math.max(0, violations - decay);
+    }
+
+    @Override
+    public final void reload(ConfigManager configuration) {
+        decay = configuration.getDoubleElse(configName + ".decay", decay);
+        setbackVL = configuration.getDoubleElse(configName + ".setbackvl", setbackVL);
+        displayName = configuration.getStringElse(configName + ".displayname", checkName);
+        description = configuration.getStringElse(configName + ".description", description);
+
+        if (setbackVL == -1) setbackVL = Double.MAX_VALUE;
+        onReload(configuration);
+    }
+
+    @Override
+    public void onReload(ConfigManager config) {
+
+    }
+
+    public boolean alert(String verbose) {
+        return player.punishmentManager.handleAlert(player, verbose, this);
+    }
+
+    public boolean setbackIfAboveSetbackVL() {
+        if (shouldSetback()) {
+            return player.getSetbackTeleportUtil().executeViolationSetback();
+        }
+        return false;
+    }
+
+    public boolean shouldSetback() {
+        return !noSetbackPermission && violations > setbackVL;
+    }
+
+    public String formatOffset(double offset) {
+        return offset > 0.001 ? String.format("%.5f", offset) : String.format("%.2E", offset);
+    }
+
+    public static boolean isTransaction(PacketTypeCommon packetType) {
+        return packetType == PacketType.Play.Client.PONG ||
+                packetType == PacketType.Play.Client.WINDOW_CONFIRMATION;
+    }
+
+    public static boolean isAsync(PacketTypeCommon packetType) {
+        return packetType == PacketType.Play.Client.KEEP_ALIVE;
+    }
+
+    public boolean isUpdate(PacketTypeCommon packetType) {
+        return isFlying(packetType)
+                || packetType == PacketType.Play.Client.CLIENT_TICK_END
+                || isTransaction(packetType);
+    }
+
+    public boolean isTickPacket(PacketTypeCommon packetType) {
+        if (isTickPacketIncludingNonMovement(packetType)) {
+            if (isFlying(packetType)) {
+                return !player.packetStateData.lastPacketWasTeleport && !player.packetStateData.lastPacketWasOnePointSeventeenDuplicate;
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public boolean isTickPacketIncludingNonMovement(PacketTypeCommon packetType) {
+        // On 1.21.2+ fall back to the TICK_END packet IF the player did not send a movement packet for their tick
+        // TickTimer checks to see if player did not send a tick end packet before new flying packet is sent
+        if (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_2)
+                && !player.packetStateData.didSendMovementBeforeTickEnd) {
+            if (packetType == PacketType.Play.Client.CLIENT_TICK_END) {
+                return true;
+            }
+        }
+
+        return isFlying(packetType);
+    }
+
+}

common/src/main/java/ac/grim/grimac/checks/GrimProcessor.java

@@ -0,0 +1,17 @@
+package ac.grim.grimac.checks;
+
+import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.api.AbstractProcessor;
+import ac.grim.grimac.api.config.ConfigReloadable;
+import ac.grim.grimac.utils.common.ConfigReloadObserver;
+
+public abstract class GrimProcessor implements AbstractProcessor, ConfigReloadable, ConfigReloadObserver {
+
+    // Not everything has to be a check for it to process packets & be configurable
+
+    @Override
+    public void reload() {
+        reload(GrimAPI.INSTANCE.getConfigManager().getConfig());
+    }
+
+}

common/src/main/java/ac/grim/grimac/checks/debug/AbstractDebugHandler.java

@@ -0,0 +1,14 @@
+package ac.grim.grimac.checks.debug;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.player.GrimPlayer;
+
+public abstract class AbstractDebugHandler extends Check {
+    public AbstractDebugHandler(GrimPlayer player) {
+        super(player);
+    }
+
+    public abstract void toggleListener(GrimPlayer player);
+
+    public abstract boolean toggleConsoleOutput();
+}

common/src/main/java/ac/grim/grimac/checks/impl/aim/AimDuplicateLook.java

@@ -8,15 +8,15 @@ import ac.grim.grimac.utils.anticheat.update.RotationUpdate;
 
 @CheckData(name = "AimDuplicateLook")
 public class AimDuplicateLook extends Check implements RotationCheck {
+    private boolean exempt;
+
     public AimDuplicateLook(GrimPlayer playerData) {
         super(playerData);
     }
 
-    boolean exempt = false;
-
     @Override
     public void process(final RotationUpdate rotationUpdate) {
-        if (player.packetStateData.lastPacketWasTeleport || player.packetStateData.lastPacketWasOnePointSeventeenDuplicate || player.compensatedEntities.getSelf().getRiding() != null) {
+        if (player.packetStateData.lastPacketWasTeleport || player.packetStateData.lastPacketWasOnePointSeventeenDuplicate || player.compensatedEntities.self.getRiding() != null) {
             exempt = true;
             return;
         }

common/src/main/java/ac/grim/grimac/checks/impl/aim/AimModulo360.java

@@ -20,12 +20,15 @@ public class AimModulo360 extends Check implements RotationCheck {
 
     @Override
     public void process(final RotationUpdate rotationUpdate) {
-        if (player.packetStateData.lastPacketWasTeleport) {
+        // Exempt for teleport, entering a vehicle due to rotation reset or
+        // after forced, client-sided rotation change after interacting with a horse (not necessarily mounting it)
+        if (player.packetStateData.lastPacketWasTeleport || player.vehicleData.wasVehicleSwitch
+                || player.packetStateData.horseInteractCausedForcedRotation) {
             lastDeltaYaw = rotationUpdate.getDeltaXRot();
             return;
         }
 
-        if (player.xRot < 360 && player.xRot > -360 && Math.abs(rotationUpdate.getDeltaXRot()) > 320 && Math.abs(lastDeltaYaw) < 30) {
+        if (player.yaw < 360 && player.yaw > -360 && Math.abs(rotationUpdate.getDeltaXRot()) > 320 && Math.abs(lastDeltaYaw) < 30) {
             flagAndAlert();
         } else {
             reward();

common/src/main/java/ac/grim/grimac/checks/impl/aim/processor/AimProcessor.java

@@ -8,37 +8,35 @@ import ac.grim.grimac.utils.data.Pair;
 import ac.grim.grimac.utils.lists.RunningMode;
 import ac.grim.grimac.utils.math.GrimMath;
 
-
 public class AimProcessor extends Check implements RotationCheck {
 
     private static final int SIGNIFICANT_SAMPLES_THRESHOLD = 15;
     private static final int TOTAL_SAMPLES_THRESHOLD = 80;
+    public double sensitivityX;
+    public double sensitivityY;
+    public double divisorX;
+    public double divisorY;
+    public double modeX, modeY;
+    public double deltaDotsX, deltaDotsY;
+    private final RunningMode xRotMode = new RunningMode(TOTAL_SAMPLES_THRESHOLD);
+    private final RunningMode yRotMode = new RunningMode(TOTAL_SAMPLES_THRESHOLD);
+    private float lastXRot;
+    private float lastYRot;
 
     public AimProcessor(GrimPlayer playerData) {
         super(playerData);
     }
 
-    RunningMode xRotMode = new RunningMode(TOTAL_SAMPLES_THRESHOLD);
-    RunningMode yRotMode = new RunningMode(TOTAL_SAMPLES_THRESHOLD);
-
-    float lastXRot;
-    float lastYRot;
-
-    public double sensitivityX;
-    public double sensitivityY;
-
-    public double divisorX;
-    public double divisorY;
-
-    public double modeX, modeY;
-
-    public double deltaDotsX, deltaDotsY;
+    public static double convertToSensitivity(double var13) {
+        double var11 = var13 / 0.15F / 8.0D;
+        double var9 = Math.cbrt(var11);
+        return (var9 - 0.2f) / 0.6f;
+    }
 
     @Override
     public void process(final RotationUpdate rotationUpdate) {
         rotationUpdate.setProcessor(this);
 
-
         float deltaXRot = rotationUpdate.getDeltaXRotABS();
 
         this.divisorX = GrimMath.gcd(deltaXRot, lastXRot);
@@ -47,7 +45,6 @@ public class AimProcessor extends Check implements RotationCheck {
             this.lastXRot = deltaXRot;
         }
 
-
         float deltaYRot = rotationUpdate.getDeltaYRotABS();
 
         this.divisorY = GrimMath.gcd(deltaYRot, lastYRot);
@@ -75,10 +72,4 @@ public class AimProcessor extends Check implements RotationCheck {
         this.deltaDotsX = deltaXRot / modeX;
         this.deltaDotsY = deltaYRot / modeY;
     }
-
-    public static double convertToSensitivity(double var13) {
-        double var11 = var13 / 0.15F / 8.0D;
-        double var9 = Math.cbrt(var11);
-        return (var9 - 0.2f) / 0.6f;
-    }
 }

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsA.java

@@ -8,9 +8,9 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientHeldItemChange;
 
-@CheckData(name = "BadPacketsA")
+@CheckData(name = "BadPacketsA", description = "Sent duplicate slot id")
 public class BadPacketsA extends Check implements PacketCheck {
-    int lastSlot = -1;
+    private int lastSlot = -1;
 
     public BadPacketsA(final GrimPlayer player) {
         super(player);

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsB.java

@@ -0,0 +1,32 @@
+package ac.grim.grimac.checks.impl.badpackets;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+
+@CheckData(name = "BadPacketsB", description = "Ignored set rotation packet")
+public class BadPacketsB extends Check implements PacketCheck {
+
+    public BadPacketsB(final GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (isTransaction(event.getPacketType())) {
+            player.pendingRotations.removeIf(data -> {
+                if (player.getLastTransactionReceived() > data.getTransaction()) {
+                    if (!data.isAccepted()) {
+                        flagAndAlert();
+                    }
+
+                    return true;
+                }
+
+                return false;
+            });
+        }
+    }
+}

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsC.java

@@ -6,9 +6,10 @@ import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.GameMode;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
 
-@CheckData(name = "BadPacketsC")
+@CheckData(name = "BadPacketsC", description = "Interacted with self")
 public class BadPacketsC extends Check implements PacketCheck {
     public BadPacketsC(GrimPlayer player) {
         super(player);
@@ -17,6 +18,7 @@ public class BadPacketsC extends Check implements PacketCheck {
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
         if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
+            if (player.gamemode == GameMode.SPECTATOR) return;
             if (new WrapperPlayClientInteractEntity(event).getEntityId() == player.entityID) {
                 // Instant ban
                 if (flagAndAlert() && shouldModifyPackets()) {

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsD.java

@@ -8,7 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
-@CheckData(name = "BadPacketsD")
+@CheckData(name = "BadPacketsD", description = "Impossible pitch")
 public class BadPacketsD extends Check implements PacketCheck {
     public BadPacketsD(GrimPlayer player) {
         super(player);
@@ -22,15 +22,13 @@ public class BadPacketsD extends Check implements PacketCheck {
             final float pitch = new WrapperPlayClientPlayerFlying(event).getLocation().getPitch();
             if (pitch > 90 || pitch < -90) {
                 // Ban.
-                if (flagAndAlert("pitch=" + pitch)) {
-                    if (shouldModifyPackets()) {
-                        // prevent other checks from using an invalid pitch
-                        if (player.yRot > 90) player.yRot = 90;
-                        if (player.yRot < -90) player.yRot = -90;
+                if (flagAndAlert("pitch=" + pitch) && shouldModifyPackets()) {
+                    // prevent other checks from using an invalid pitch
+                    if (player.pitch > 90) player.pitch = 90;
+                    if (player.pitch < -90) player.pitch = -90;
 
-                        event.setCancelled(true);
-                        player.onPacketCancel();
-                    }
+                    event.setCancelled(true);
+                    player.onPacketCancel();
                 }
             }
         }

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsE.java

@@ -4,13 +4,18 @@ import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
 @CheckData(name = "BadPacketsE")
 public class BadPacketsE extends Check implements PacketCheck {
     private int noReminderTicks;
+    private final int maxNoReminderTicks = player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8) ? 20 : 19;
+    private final boolean isViaPleaseStopUsingProtocolHacksOnYourServer = player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_2) || PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_21_2);
 
     public BadPacketsE(GrimPlayer player) {
         super(player);
@@ -21,15 +26,14 @@ public class BadPacketsE extends Check implements PacketCheck {
         if (event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION ||
                 event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION) {
             noReminderTicks = 0;
-        } else if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType())) {
-            noReminderTicks++;
-        } else if (event.getPacketType() == PacketType.Play.Client.STEER_VEHICLE) {
+        } else if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType()) && !player.packetStateData.lastPacketWasTeleport) {
+            if (++noReminderTicks > maxNoReminderTicks) {
+                flagAndAlert("ticks=" + noReminderTicks);
+            }
+        } else if (event.getPacketType() == PacketType.Play.Client.STEER_VEHICLE
+                || (isViaPleaseStopUsingProtocolHacksOnYourServer && player.inVehicle())) {
             noReminderTicks = 0; // Exempt vehicles
         }
-
-        if (noReminderTicks > 20) {
-            flagAndAlert("ticks=" + noReminderTicks); // ban?  I don't know how this would false
-        }
     }
 
     public void handleRespawn() {

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsF.java

@@ -8,7 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
 
-@CheckData(name = "BadPacketsF")
+@CheckData(name = "BadPacketsF", description = "Sent duplicate sprinting status")
 public class BadPacketsF extends Check implements PacketCheck {
     public boolean lastSprinting;
     public boolean exemptNext = true; // Support 1.14+ clients starting on either true or false sprinting, we don't know

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsG.java

@@ -8,10 +8,9 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
 
-@CheckData(name = "BadPacketsG")
+@CheckData(name = "BadPacketsG", description = "Sent duplicate sneaking status")
 public class BadPacketsG extends Check implements PacketCheck {
-    boolean wasTeleport;
-    boolean lastSneaking;
+    private boolean lastSneaking, respawn;
 
     public BadPacketsG(GrimPlayer player) {
         super(player);
@@ -19,13 +18,12 @@ public class BadPacketsG extends Check implements PacketCheck {
 
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
-        wasTeleport = player.packetStateData.lastPacketWasTeleport || wasTeleport;
-
         if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION) {
             WrapperPlayClientEntityAction packet = new WrapperPlayClientEntityAction(event);
 
             if (packet.getAction() == WrapperPlayClientEntityAction.Action.START_SNEAKING) {
-                if (lastSneaking && !wasTeleport) {
+                // The player may send two START_SNEAKING packets if they respawned
+                if (lastSneaking && !respawn) {
                     if (flagAndAlert("state=true") && shouldModifyPackets()) {
                         event.setCancelled(true);
                         player.onPacketCancel();
@@ -33,8 +31,9 @@ public class BadPacketsG extends Check implements PacketCheck {
                 } else {
                     lastSneaking = true;
                 }
+                respawn = false;
             } else if (packet.getAction() == WrapperPlayClientEntityAction.Action.STOP_SNEAKING) {
-                if (!lastSneaking && !wasTeleport) {
+                if (!lastSneaking && !respawn) {
                     if (flagAndAlert("state=false") && shouldModifyPackets()) {
                         event.setCancelled(true);
                         player.onPacketCancel();
@@ -42,7 +41,13 @@ public class BadPacketsG extends Check implements PacketCheck {
                 } else {
                     lastSneaking = false;
                 }
+                respawn = false;
             }
         }
     }
+
+    public void handleRespawn() {
+        // Clients could potentially not send a STOP_SNEAKING packet when they die, so we need to track it
+        respawn = true;
+    }
 }

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsH.java

@@ -0,0 +1,67 @@
+package ac.grim.grimac.checks.impl.badpackets;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.BlockPlaceCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.BlockBreak;
+import ac.grim.grimac.utils.anticheat.update.BlockPlace;
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientUseItem;
+
+@CheckData(name = "BadPacketsH", description = "Sent unexpected sequence id", experimental = true)
+public class BadPacketsH extends BlockPlaceCheck {
+    private int lastSequence;
+    private final boolean isSupportedVersion = player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_19) && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_19);
+
+    public BadPacketsH(final GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.USE_ITEM
+                && shouldCancel(new WrapperPlayClientUseItem(event).getSequence())) {
+            event.setCancelled(true);
+            player.onPacketCancel();
+        }
+    }
+
+    @Override
+    public void onBlockPlace(BlockPlace place) {
+        if (shouldCancel(place.sequence) && shouldCancel()) {
+            place.resync();
+        }
+    }
+
+    @Override
+    public void onBlockBreak(BlockBreak blockBreak) {
+        switch (blockBreak.action) {
+            case START_DIGGING, FINISHED_DIGGING -> {
+                if (shouldCancel(blockBreak.sequence)) {
+                    blockBreak.cancel();
+                }
+            }
+            case CANCELLED_DIGGING -> { // other actions will be checked by BadPacketsL
+                if (blockBreak.sequence != 0 && flagAndAlert("expected=0, id=" + blockBreak.sequence) && shouldModifyPackets()) {
+                    blockBreak.cancel();
+                }
+            }
+        }
+    }
+
+    public boolean shouldCancel(int sequence) {
+        int expected = lastSequence + 1;
+        lastSequence = sequence;
+        return isSupportedVersion && sequence != expected
+                && flagAndAlert("expected=" + expected + ", id=" + sequence)
+                && shouldModifyPackets();
+    }
+
+    public void onWorldChange() {
+        lastSequence = 0;
+    }
+}

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsI.java

@@ -8,7 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerAbilities;
 
-@CheckData(name = "BadPacketsI")
+@CheckData(name = "BadPacketsI", description = "Claimed to be flying while unable to fly")
 public class BadPacketsI extends Check implements PacketCheck {
     public BadPacketsI(GrimPlayer player) {
         super(player);
@@ -16,13 +16,11 @@ public class BadPacketsI extends Check implements PacketCheck {
 
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
-        if (event.getPacketType() == PacketType.Play.Client.PLAYER_ABILITIES) {
-            if (new WrapperPlayClientPlayerAbilities(event).isFlying() && !player.canFly) {
-                if (flagAndAlert() && shouldModifyPackets()) {
-                    event.setCancelled(true);
-                    player.onPacketCancel();
-                }
-            }
+        if (event.getPacketType() == PacketType.Play.Client.PLAYER_ABILITIES
+                && new WrapperPlayClientPlayerAbilities(event).isFlying() && !player.canFly
+                && flagAndAlert() && shouldModifyPackets()) {
+            event.setCancelled(true);
+            player.onPacketCancel();
         }
     }
 }

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsJ.java

@@ -0,0 +1,59 @@
+package ac.grim.grimac.checks.impl.badpackets;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.data.HeadRotation;
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.protocol.player.GameMode;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientUseItem;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@CheckData(name = "BadPacketsJ", description = "Rotation in use item packet did not match tick rotation")
+public class BadPacketsJ extends Check implements PacketCheck {
+    private final List<HeadRotation> rotations = new ArrayList<>();
+
+    public BadPacketsJ(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.gamemode == GameMode.SPECTATOR) {
+            rotations.clear();
+            return;
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.USE_ITEM && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21)
+                && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_21)) {
+            WrapperPlayClientUseItem packet = new WrapperPlayClientUseItem(event);
+            rotations.add(new HeadRotation(packet.getYaw(), packet.getPitch()));
+        }
+
+        if (isTickPacket(event.getPacketType())) {
+            // due to tick skipping, the rotations sent could be last tick's
+            boolean allowLast = player.canSkipTicks() && (event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION || event.getPacketType() == PacketType.Play.Client.PLAYER_ROTATION);
+            for (HeadRotation rotation : rotations) {
+                if (rotation.yaw() == player.yaw && rotation.pitch() == player.pitch) {
+                    allowLast = false;
+                    continue;
+                }
+
+                if (rotation.yaw() == player.lastYaw && rotation.pitch() == player.lastPitch && allowLast) {
+                    continue;
+                }
+
+                flagAndAlert();
+            }
+
+            rotations.clear();
+        }
+    }
+}

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsK.java

@@ -8,7 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.GameMode;
 
-@CheckData(name = "BadPacketsK")
+@CheckData(name = "BadPacketsK", description = "Sent spectate packets while not in spectator mode")
 public class BadPacketsK extends Check implements PacketCheck {
     public BadPacketsK(GrimPlayer player) {
         super(player);
@@ -16,13 +16,11 @@ public class BadPacketsK extends Check implements PacketCheck {
 
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
-        if (event.getPacketType() == PacketType.Play.Client.SPECTATE) {
-            if (player.gamemode != GameMode.SPECTATOR) {
-                if (flagAndAlert() && shouldModifyPackets()) {
-                    event.setCancelled(true);
-                    player.onPacketCancel();
-                }
-            }
+        if (event.getPacketType() == PacketType.Play.Client.SPECTATE
+                && player.gamemode != GameMode.SPECTATOR
+                && flagAndAlert() && shouldModifyPackets()) {
+            event.setCancelled(true);
+            player.onPacketCancel();
         }
     }
 }

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsL.java

@@ -8,13 +8,11 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.protocol.player.DiggingAction;
-import com.github.retrooper.packetevents.protocol.world.BlockFace;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
 
 import java.util.Locale;
 
-// checks for impossible dig packets
-@CheckData(name = "BadPacketsL")
+@CheckData(name = "BadPacketsL", description = "Sent impossible dig packet")
 public class BadPacketsL extends Check implements PacketCheck {
 
     public BadPacketsL(GrimPlayer player) {
@@ -26,23 +24,25 @@ public class BadPacketsL extends Check implements PacketCheck {
         if (event.getPacketType() == PacketType.Play.Client.PLAYER_DIGGING) {
             final WrapperPlayClientPlayerDigging packet = new WrapperPlayClientPlayerDigging(event);
 
-            if (packet.getAction() == DiggingAction.START_DIGGING || packet.getAction() == DiggingAction.FINISHED_DIGGING || packet.getAction() == DiggingAction.CANCELLED_DIGGING) return;
+            if (packet.getAction() == DiggingAction.START_DIGGING || packet.getAction() == DiggingAction.FINISHED_DIGGING || packet.getAction() == DiggingAction.CANCELLED_DIGGING)
+                return;
 
             // 1.8 and above clients always send digging packets that aren't used for digging at 0, 0, 0, facing DOWN
             // 1.7 and below clients do the same, except use SOUTH for RELEASE_USE_ITEM
-            final BlockFace expectedFace = player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_7_10) && packet.getAction() == DiggingAction.RELEASE_USE_ITEM
-                    ? BlockFace.SOUTH : BlockFace.DOWN;
+            final int expectedFace = player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_7_10) && packet.getAction() == DiggingAction.RELEASE_USE_ITEM
+                    ? 255 : 0;
 
-            if (packet.getBlockFace() != expectedFace
+            if (packet.getBlockFaceId() != expectedFace
                     || packet.getBlockPosition().getX() != 0
                     || packet.getBlockPosition().getY() != 0
                     || packet.getBlockPosition().getZ() != 0
                     || packet.getSequence() != 0
             ) {
-                if (flagAndAlert("xyzF="
-                        + packet.getBlockPosition().getX() + ", " + packet.getBlockPosition().getY() + ", " + packet.getBlockPosition().getZ() + ", " + packet.getBlockFace()
+                if (flagAndAlert("pos="
+                        + packet.getBlockPosition().getX() + ", " + packet.getBlockPosition().getY() + ", " + packet.getBlockPosition().getZ()
+                        + ", face=" + packet.getBlockFace()
                         + ", sequence=" + packet.getSequence()
-                        + ", action=" + packet.getAction().toString().toLowerCase(Locale.ROOT).replace("_", " ") + " v" + player.getVersionName()
+                        + ", action=" + packet.getAction().toString().toLowerCase(Locale.ROOT)
                 ) && shouldModifyPackets() && packet.getAction() != DiggingAction.RELEASE_USE_ITEM) {
                     event.setCancelled(true);
                     player.onPacketCancel();

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsM.java

@@ -0,0 +1,64 @@
+package ac.grim.grimac.checks.impl.badpackets;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.event.PacketSendEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.protocol.player.Combat;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientClientStatus;
+import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerChangeGameState;
+import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerCombatEvent;
+import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerDeathCombatEvent;
+
+@CheckData(name = "BadPacketsM", description = "Tried to respawn while alive", experimental = true)
+public class BadPacketsM extends Check implements PacketCheck {
+    public BadPacketsM(final GrimPlayer player) {
+        super(player);
+    }
+
+    // not a boolean because the server could send packets that cause
+    // the client to send a respawn packet before it receives the first
+    private int exempt;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.CLIENT_STATUS && new WrapperPlayClientClientStatus(event).getAction() == WrapperPlayClientClientStatus.Action.PERFORM_RESPAWN) {
+            if (exempt > 0) {
+                exempt--;
+                return;
+            }
+
+            if (!player.compensatedEntities.self.isDead) {
+                if (flagAndAlert() && shouldModifyPackets()) {
+                    event.setCancelled(true);
+                    player.onPacketCancel();
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onPacketSend(PacketSendEvent event) {
+        if (event.getPacketType() == PacketType.Play.Server.CHANGE_GAME_STATE && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_9)
+                && new WrapperPlayServerChangeGameState(event).getReason() == WrapperPlayServerChangeGameState.Reason.WIN_GAME) {
+            player.addRealTimeTaskNow(() -> exempt++);
+        }
+
+        if (event.getPacketType() == PacketType.Play.Server.DEATH_COMBAT_EVENT && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_9)) {
+            if (new WrapperPlayServerDeathCombatEvent(event).getPlayerId() == player.entityID) {
+                player.addRealTimeTaskNow(() -> exempt++);
+            }
+        }
+
+        if (event.getPacketType() == PacketType.Play.Server.COMBAT_EVENT && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_9)) {
+            WrapperPlayServerCombatEvent packet = new WrapperPlayServerCombatEvent(event);
+            if (packet.getCombat() == Combat.ENTITY_DEAD && packet.getPlayerId() == player.entityID) {
+                player.addRealTimeTaskNow(() -> exempt++);
+            }
+        }
+    }
+}

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsN.java

@@ -2,11 +2,10 @@ package ac.grim.grimac.checks.impl.badpackets;
 
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 
-@CheckData(name = "BadPacketsN")
-public class BadPacketsN extends Check implements PacketCheck {
+@CheckData(name = "BadPacketsN", setback = 0)
+public class BadPacketsN extends Check {
     public BadPacketsN(final GrimPlayer player) {
         super(player);
     }

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsO.java

@@ -4,7 +4,6 @@ import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
-import ac.grim.grimac.utils.data.Pair;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.event.PacketSendEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
@@ -12,11 +11,10 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientKe
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerKeepAlive;
 
 import java.util.LinkedList;
-import java.util.Queue;
 
 @CheckData(name = "BadPacketsO")
 public class BadPacketsO extends Check implements PacketCheck {
-    Queue<Pair<Long, Long>> keepaliveMap = new LinkedList<>();
+    private final LinkedList<Long> keepalives = new LinkedList<>();
 
     public BadPacketsO(GrimPlayer player) {
         super(player);
@@ -25,37 +23,30 @@ public class BadPacketsO extends Check implements PacketCheck {
     @Override
     public void onPacketSend(PacketSendEvent event) {
         if (event.getPacketType() == PacketType.Play.Server.KEEP_ALIVE) {
-            WrapperPlayServerKeepAlive packet = new WrapperPlayServerKeepAlive(event);
-            keepaliveMap.add(new Pair<>(packet.getId(), System.nanoTime()));
+            keepalives.add(new WrapperPlayServerKeepAlive(event).getId());
         }
     }
 
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
         if (event.getPacketType() == PacketType.Play.Client.KEEP_ALIVE) {
-            WrapperPlayClientKeepAlive packet = new WrapperPlayClientKeepAlive(event);
+            final long id = new WrapperPlayClientKeepAlive(event).getId();
 
-            long id = packet.getId();
-            boolean hasID = false;
+            for (long keepalive : keepalives) {
+                if (keepalive == id) {
+                    // Found the ID, remove stuff until we get to it (to stop very slow memory leaks)
+                    Long data;
+                    do {
+                        data = keepalives.poll();
+                    } while (data != null && data != id);
 
-            for (Pair<Long, Long> iterator : keepaliveMap) {
-                if (iterator.first() == id) {
-                    hasID = true;
-                    break;
+                    return;
                 }
             }
 
-            if (!hasID) {
-                if (flagAndAlert("id=" + id) && shouldModifyPackets()) {
-                    event.setCancelled(true);
-                    player.onPacketCancel();
-                }
-            } else { // Found the ID, remove stuff until we get to it (to stop very slow memory leaks)
-                Pair<Long, Long> data;
-                do {
-                    data = keepaliveMap.poll();
-                    if (data == null) break;
-                } while (data.first() != id);
+            if (flagAndAlert("id=" + id) && shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
             }
         }
     }

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsP.java

@@ -8,18 +8,19 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.event.PacketSendEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientClickWindow;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientClickWindow.WindowClickType;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerOpenWindow;
 
-@CheckData(name = "BadPacketsP", experimental = true)
+@CheckData(name = "BadPacketsP", description = "Invalid click packets", experimental = true)
 public class BadPacketsP extends Check implements PacketCheck {
 
+    private int containerType = -1;
+    private int containerId = -1;
+
     public BadPacketsP(GrimPlayer playerData) {
         super(playerData);
     }
 
-    private int containerType = -1;
-    private int containerId = -1;
-
     @Override
     public void onPacketSend(final PacketSendEvent event) {
         if (event.getPacketType() == PacketType.Play.Server.OPEN_WINDOW) {
@@ -33,35 +34,22 @@ public class BadPacketsP extends Check implements PacketCheck {
     public void onPacketReceive(PacketReceiveEvent event) {
         if (event.getPacketType() == PacketType.Play.Client.CLICK_WINDOW) {
             WrapperPlayClientClickWindow wrapper = new WrapperPlayClientClickWindow(event);
-            int clickType = wrapper.getWindowClickType().ordinal();
+            WindowClickType clickType = wrapper.getWindowClickType();
             int button = wrapper.getButton();
 
-            boolean flag = false;
+            // TODO: Adjust for containers
+            boolean flag = switch (clickType) {
+                case PICKUP, QUICK_MOVE, CLONE -> button > 2 || button < 0;
+                case SWAP -> (button > 8 || button < 0) && button != 40;
+                case THROW -> button != 0 && button != 1;
+                case QUICK_CRAFT -> button == 3 || button == 7 || button > 10 || button < 0;
+                case PICKUP_ALL -> button != 0;
+                case UNKNOWN -> true;
+            };
 
-            //TODO: Adjust for containers
-            switch (clickType) {
-                case 0:
-                case 1:
-                case 4:
-                    if (button != 0 && button != 1) flag = true;
-                    break;
-                case 2:
-                    if ((button > 8 || button < 0) && button != 40) flag = true;
-                    break;
-                case 3:
-                    if (button != 2) flag = true;
-                    break;
-                case 5:
-                    if (button == 3 || button == 7 || button > 10 || button < 0) flag = true;
-                    break;
-                case 6:
-                    if (button != 0) flag = true;
-                    break;
-            }
-
-            //Allowing this to false flag to debug and find issues faster
+            // Allowing this to false flag to debug and find issues faster
             if (flag) {
-                if (flagAndAlert("clickType=" + clickType + " button=" + button + (wrapper.getWindowId() == containerId ? " container=" + containerType : "")) && shouldModifyPackets()) {
+                if (flagAndAlert("clickType=" + clickType.toString().toLowerCase() + ", button=" + button + (wrapper.getWindowId() == containerId ? ", container=" + containerType : "")) && shouldModifyPackets()) {
                     event.setCancelled(true);
                     player.onPacketCancel();
                 }

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsQ.java

@@ -19,8 +19,10 @@ public class BadPacketsQ extends Check implements PacketCheck {
     public void onPacketReceive(PacketReceiveEvent event) {
         if (event.getPacketType() == Client.ENTITY_ACTION) {
             WrapperPlayClientEntityAction wrapper = new WrapperPlayClientEntityAction(event);
-
-            if (wrapper.getJumpBoost() < 0 || wrapper.getJumpBoost() > 100 || wrapper.getEntityId() != player.entityID || (wrapper.getAction() != Action.START_JUMPING_WITH_HORSE && wrapper.getJumpBoost() != 0)) {
+            // you are able to send negative jump boost, how and why!?
+            if (Math.abs(wrapper.getJumpBoost()) > 100
+                    || wrapper.getEntityId() != player.entityID
+                    || wrapper.getAction() != Action.START_JUMPING_WITH_HORSE && wrapper.getJumpBoost() != 0) {
                 if (flagAndAlert("boost=" + wrapper.getJumpBoost() + ", action=" + wrapper.getAction() + ", entity=" + wrapper.getEntityId()) && shouldModifyPackets()) {
                     event.setCancelled(true);
                     player.onPacketCancel();

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsR.java

@@ -10,26 +10,27 @@ import com.github.retrooper.packetevents.protocol.player.GameMode;
 
 @CheckData(name = "BadPacketsR", decay = 0.25, experimental = true)
 public class BadPacketsR extends Check implements PacketCheck {
-    public BadPacketsR(final GrimPlayer player) {
-        super(player);
-    }
-
     private int positions = 0;
     private long clock = 0;
     private long lastTransTime;
     private int oldTransId = 0;
 
+    public BadPacketsR(final GrimPlayer player) {
+        super(player);
+    }
+
     @Override
     public void onPacketReceive(final PacketReceiveEvent event) {
         if (isTransaction(event.getPacketType()) && player.packetStateData.lastTransactionPacketWasValid) {
             long ms = (player.getPlayerClockAtLeast() - clock) / 1000000L;
             long diff = (System.currentTimeMillis() - lastTransTime);
             if (diff > 2000 && ms > 2000) {
-                if (positions == 0 && clock != 0 && player.gamemode != GameMode.SPECTATOR && !player.compensatedEntities.getSelf().isDead) {
-                    flagAndAlert("time=" + ms + "ms, " + "lst=" + diff + "ms, positions=" + positions);
+                if (positions == 0 && clock != 0 && player.gamemode != GameMode.SPECTATOR && !player.compensatedEntities.self.isDead) {
+                    flag("time=" + ms + "ms, " + "lst=" + diff + "ms, positions=" + positions);
                 } else {
                     reward();
                 }
+                player.compensatedEntities.entitiesRemovedThisTick.clear();
                 player.compensatedWorld.removeInvalidPistonLikeStuff(oldTransId);
                 positions = 0;
                 clock = player.getPlayerClockAtLeast();
@@ -39,9 +40,10 @@ public class BadPacketsR extends Check implements PacketCheck {
         }
         //
         if ((event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION ||
-                event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION) && !player.compensatedEntities.getSelf().inVehicle()) {
+                event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION) && !player.inVehicle()) {
             positions++;
-        } else if (event.getPacketType() == PacketType.Play.Client.STEER_VEHICLE && player.compensatedEntities.getSelf().inVehicle()) {
+        } else if ((event.getPacketType() == PacketType.Play.Client.STEER_VEHICLE || event.getPacketType() == PacketType.Play.Client.VEHICLE_MOVE)
+                && player.inVehicle()) {
             positions++;
         }
     }

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsS.java

@@ -0,0 +1,26 @@
+package ac.grim.grimac.checks.impl.badpackets;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientWindowConfirmation;
+
+@CheckData(name = "BadPacketsS")
+public class BadPacketsS extends Check implements PacketCheck {
+    public BadPacketsS(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.WINDOW_CONFIRMATION
+                && !new WrapperPlayClientWindowConfirmation(event).isAccepted()
+                && flagAndAlert() && shouldModifyPackets()) {
+            event.setCancelled(true);
+            player.onPacketCancel();
+        }
+    }
+}

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsT.java

@@ -14,18 +14,22 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientIn
 
 @CheckData(name = "BadPacketsT")
 public class BadPacketsT extends Check implements PacketCheck {
+
+    private final double maxHorizontalDisplacement;
+    private final double minVerticalDisplacement;
+    private final double maxVerticalDisplacement;
+
     public BadPacketsT(final GrimPlayer player) {
         super(player);
+        // 1.7 and 1.8 seem to have different hitbox "expansion" values than 1.9+
+        // https://github.com/GrimAnticheat/Grim/pull/1274#issuecomment-1872458702
+        // https://github.com/GrimAnticheat/Grim/pull/1274#issuecomment-1872533497
+        double expansion = player.getClientVersion().isOlderThan(ClientVersion.V_1_9) ? 0.1 : 0;
+        maxHorizontalDisplacement = 0.3001 + expansion;
+        minVerticalDisplacement = -0.0001 - expansion;
+        maxVerticalDisplacement = 1.8001 + expansion;
     }
 
-    // 1.7 and 1.8 seem to have different hitbox "expansion" values than 1.9+
-    // https://github.com/GrimAnticheat/Grim/pull/1274#issuecomment-1872458702
-    // https://github.com/GrimAnticheat/Grim/pull/1274#issuecomment-1872533497
-    private final boolean hasLegacyExpansion = player.getClientVersion().isOlderThan(ClientVersion.V_1_9);
-    private final double maxHorizontalDisplacement = 0.3001 + (hasLegacyExpansion ? 0.1 : 0);
-    private final double minVerticalDisplacement = -0.0001 - (hasLegacyExpansion ? 0.1 : 0);
-    private final double maxVerticalDisplacement = 1.8001 + (hasLegacyExpansion ? 0.1 : 0);
-
     @Override
     public void onPacketReceive(final PacketReceiveEvent event) {
         if (event.getPacketType().equals(PacketType.Play.Client.INTERACT_ENTITY)) {
@@ -39,7 +43,7 @@ public class BadPacketsT extends Check implements PacketCheck {
                 }
 
                 // Make sure our target entity is actually a player (Player NPCs work too)
-                if (!EntityTypes.PLAYER.equals(packetEntity.getType())) {
+                if (!EntityTypes.PLAYER.equals(packetEntity.type)) {
                     // We can't check for any entity that is not a player
                     return;
                 }
@@ -49,7 +53,7 @@ public class BadPacketsT extends Check implements PacketCheck {
                 //  27/12/2023 - Dynamic values for more than just one entity type?
                 //  28/12/2023 - Player-only is fine
                 //  30/12/2023 - Expansions differ in 1.9+
-                final float scale = (float) packetEntity.getAttributeValue(Attributes.GENERIC_SCALE);
+                final float scale = (float) packetEntity.getAttributeValue(Attributes.SCALE);
                 if (targetVector.y > (minVerticalDisplacement * scale) && targetVector.y < (maxVerticalDisplacement * scale)
                         && Math.abs(targetVector.x) < (maxHorizontalDisplacement * scale)
                         && Math.abs(targetVector.z) < (maxHorizontalDisplacement * scale)) {

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsU.java

@@ -14,7 +14,7 @@ import com.github.retrooper.packetevents.util.Vector3f;
 import com.github.retrooper.packetevents.util.Vector3i;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerBlockPlacement;
 
-@CheckData(name = "BadPacketsU", experimental = true)
+@CheckData(name = "BadPacketsU", description = "Sent impossible use item packet")
 public class BadPacketsU extends Check implements PacketCheck {
     public BadPacketsU(GrimPlayer player) {
         super(player);

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsV.java

@@ -0,0 +1,41 @@
+package ac.grim.grimac.checks.impl.badpackets;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.util.Vector3d;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
+
+@CheckData(name = "BadPacketsV", description = "Did not move far enough", experimental = true)
+public class BadPacketsV extends Check implements PacketCheck {
+    private int noReminderTicks;
+
+    public BadPacketsV(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (!player.canSkipTicks() && isTickPacket(event.getPacketType())) {
+            if (event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION || event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION) {
+                int positionAtLeastEveryNTicks = player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8) ? 20 : 19;
+
+                if (noReminderTicks < positionAtLeastEveryNTicks && !player.uncertaintyHandler.lastTeleportTicks.hasOccurredSince(1)) {
+                    final double deltaSq = new WrapperPlayClientPlayerFlying(event).getLocation().getPosition()
+                            .distanceSquared(new Vector3d(player.lastX, player.lastY, player.lastZ));
+                    if (deltaSq <= player.getMovementThreshold() * player.getMovementThreshold()) {
+                        flagAndAlert("delta=" + Math.sqrt(deltaSq));
+                    }
+                }
+
+                noReminderTicks = 0;
+            } else {
+                noReminderTicks++;
+            }
+        }
+    }
+}

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsW.java

@@ -2,11 +2,10 @@ package ac.grim.grimac.checks.impl.badpackets;
 
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 
-@CheckData(name = "BadPacketsW", experimental = true)
-public class BadPacketsW extends Check implements PacketCheck {
+@CheckData(name = "BadPacketsW", description = "Interacted with non-existent entity", experimental = true)
+public class BadPacketsW extends Check {
     public BadPacketsW(GrimPlayer player) {
         super(player);
     }

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsX.java

@@ -0,0 +1,77 @@
+package ac.grim.grimac.checks.impl.badpackets;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PostPredictionCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.GameMode;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
+
+@CheckData(name = "BadPacketsX", experimental = true)
+public class BadPacketsX extends Check implements PostPredictionCheck {
+    private boolean sprint;
+    private boolean sneak;
+    private int flags;
+
+    public BadPacketsX(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPredictionComplete(final PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) {
+            if (flags > 0) {
+                setbackIfAboveSetbackVL();
+            }
+
+            flags = 0;
+            return;
+        }
+
+        if (player.isTickingReliablyFor(3)) {
+            for (; flags > 0; flags--) {
+                flagAndAlertWithSetback();
+            }
+        }
+
+        flags = 0;
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.gamemode == GameMode.SPECTATOR || isTickPacket(event.getPacketType())) {
+            sprint = sneak = false;
+            return;
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION) {
+            switch (new WrapperPlayClientEntityAction(event).getAction()) {
+                case START_SNEAKING, STOP_SNEAKING -> {
+                    if (sneak) {
+                        if (player.canSkipTicks() || flagAndAlert()) {
+                            flags++;
+                        }
+                    }
+
+                    sneak = true;
+                }
+                case START_SPRINTING, STOP_SPRINTING -> {
+                    if (player.inVehicle()) {
+                        return;
+                    }
+
+                    if (sprint) {
+                        if (player.canSkipTicks() || flagAndAlert()) {
+                            flags++;
+                        }
+                    }
+
+                    sprint = true;
+                }
+            }
+        }
+    }
+}

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsY.java

@@ -8,10 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientHeldItemChange;
 
-/**
- * Checks for out of bounds slot changes
- */
-@CheckData(name = "BadPacketsY")
+@CheckData(name = "BadPacketsY", description = "Sent out of bounds slot id")
 public class BadPacketsY extends Check implements PacketCheck {
     public BadPacketsY(GrimPlayer player) {
         super(player);
@@ -22,7 +19,7 @@ public class BadPacketsY extends Check implements PacketCheck {
         if (event.getPacketType() == PacketType.Play.Client.HELD_ITEM_CHANGE) {
             final int slot = new WrapperPlayClientHeldItemChange(event).getSlot();
             if (slot > 8 || slot < 0) { // ban
-                if (flagAndAlert("slot="+slot) && shouldModifyPackets()) {
+                if (flagAndAlert("slot=" + slot) && shouldModifyPackets()) {
                     event.setCancelled(true);
                     player.onPacketCancel();
                 }

common/src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsZ.java

@@ -0,0 +1,32 @@
+package ac.grim.grimac.checks.impl.badpackets;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+
+@CheckData(name = "BadPacketsZ", experimental = true)
+public class BadPacketsZ extends Check implements PacketCheck {
+    private boolean sent;
+
+    public BadPacketsZ(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.CLIENT_TICK_END) {
+            sent = false;
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.PLAYER_INPUT) {
+            if (sent) {
+                flagAndAlert();
+            }
+
+            sent = true;
+        }
+    }
+}