From b597c54743e441035f1b54083ab2a7b3e08cbe54 Mon Sep 17 00:00:00 2001
From: Pasqual Koschmieder <git@derklaro.dev>
Date: Mon, 3 Feb 2025 12:10:36 +0100
Subject: [PATCH] feat: add fabric implementation (#138)

---
 .github/workflows/validate.yml                |   2 +-
 .idea/codeStyles/Project.xml                  |   2 -
 README.md                                     |  25 +-
 build.gradle.kts                              |   1 +
 checkstyle.xml                                |   2 +-
 fabric/build.gradle.kts                       |  70 +++
 .../npclib/fabric/FabricModInitializer.java   |  35 ++
 .../juliarn/npclib/fabric/FabricPlatform.java | 101 +++++
 .../npclib/fabric/FabricPlatformLogger.java   |  64 +++
 .../fabric/FabricPlatformTaskManager.java     |  53 +++
 .../npclib/fabric/FabricVersionAccessor.java  |  85 ++++
 .../npclib/fabric/FabricWorldAccessor.java    |  61 +++
 .../controller/FabricActionController.java    | 220 ++++++++++
 .../FabricActionControllerEvents.java         | 161 +++++++
 .../fabric/mixins/MinecraftServerMixin.java   |  41 ++
 .../npclib/fabric/mixins/PlayerListMixin.java |  57 +++
 .../ServerGamePacketListenerImplMixin.java    | 169 ++++++++
 .../fabric/mixins/ServerPlayerMixin.java      |  51 +++
 .../protocol/ByteArrayCustomPayload.java      |  43 ++
 .../fabric/protocol/EntityDataFactory.java    |  34 ++
 .../protocol/FabricProtocolAdapter.java       | 404 ++++++++++++++++++
 .../npclib/fabric/util/FabricUtil.java        |  74 ++++
 fabric/src/main/resources/fabric.mod.json     |  31 ++
 .../src/main/resources/npc_lib.accesswidener  |  16 +
 fabric/src/main/resources/npc_lib.mixins.json |  14 +
 gradle/libs.versions.toml                     |  13 +
 settings.gradle.kts                           |  12 +-
 27 files changed, 1827 insertions(+), 14 deletions(-)
 create mode 100644 fabric/build.gradle.kts
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricModInitializer.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricPlatform.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricPlatformLogger.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricPlatformTaskManager.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricVersionAccessor.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricWorldAccessor.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/controller/FabricActionController.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/controller/FabricActionControllerEvents.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/MinecraftServerMixin.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/PlayerListMixin.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/ServerGamePacketListenerImplMixin.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/ServerPlayerMixin.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/protocol/ByteArrayCustomPayload.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/protocol/EntityDataFactory.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/protocol/FabricProtocolAdapter.java
 create mode 100644 fabric/src/main/java/com/github/juliarn/npclib/fabric/util/FabricUtil.java
 create mode 100644 fabric/src/main/resources/fabric.mod.json
 create mode 100644 fabric/src/main/resources/npc_lib.accesswidener
 create mode 100644 fabric/src/main/resources/npc_lib.mixins.json

diff --git a/.github/workflows/validate.yml b/.github/workflows/validate.yml
index 62a1d28..f850df9 100644
--- a/.github/workflows/validate.yml
+++ b/.github/workflows/validate.yml
@@ -22,7 +22,7 @@ jobs:
       - name: Setup java
         uses: actions/setup-java@v4
         with:
-          java-version: 17
+          java-version: 21
           check-latest: true
           distribution: 'zulu'
 
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index b0cd35f..5cb222b 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -240,10 +240,8 @@
       </indentOptions>
     </codeStyleSettings>
     <codeStyleSettings language="Python">
-      <option name="KEEP_BLANK_LINES_IN_CODE" value="1" />
       <option name="RIGHT_MARGIN" value="80" />
       <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
-      <option name="PARENT_SETTINGS_INSTALLED" value="true" />
       <indentOptions>
         <option name="INDENT_SIZE" value="2" />
         <option name="CONTINUATION_INDENT_SIZE" value="4" />
diff --git a/README.md b/README.md
index 4d36c90..545a94e 100644
--- a/README.md
+++ b/README.md
@@ -15,10 +15,10 @@
 ## Features
 
 - **Bukkit & Forks** (including Folia) supported via **ProtocolLib** or **PacketEvents**
-- **Minestom** supported
+- Full **Minestom** & **Fabric** support (latest version only)
 - **Skin** (Static and Dynamic loading)
 - **Attributes** (Status, Pose, Skin Layers)
-- **Equipment** (Main & Off Hand, Armor)
+- **Equipment** (Main & Off-Hand, Armor)
 - **Interaction** (Interact & Attack)
 - **Action Controller** (Automatic Looking at Player, Player Imitation & Spawning etc.)
 - **LabyMod Extension** (Sending Emotes & Sprays)
@@ -30,13 +30,14 @@ There are some **[images](#images)** down below showcasing the use and features
 
 All modules are available in [maven central](https://central.sonatype.com/search?q=io.github.juliarn):
 
-| Module artifact name | Module description                                                                                                                                                                    |
-|----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| npc-lib-api          | General NPC-Lib API without platform specific class usage. This module should be used when the underlying implementation does not matter.                                             |
-| npc-lib-common       | Abstract implementation of the api module. This module should be used when a new platform implementation is made.                                                                     |
-| npc-lib-bukkit       | Platform specific implementation for Bukkit. This module implements the complete API (and common) to support Bukkit (and forks).                                                      |
-| npc-lib-minestom     | Platform specific implementation for Minestom. This module implements the complete API (and common) to support Minestom (and forks).                                                  |
-| npc-lib-labymod      | This module contains helper methods for accessing LabyMod NPC features (such as emotes and stickers). See the [LabyMod documentation](https://dev.labymod.net/) for more information. |
+| Module artifact name | Module description                                                                                                                                                                                    |
+|----------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| npc-lib-api          | General NPC-Lib API without platform specific class usage. This module should be used when the underlying implementation does not matter.                                                             |
+| npc-lib-common       | Abstract implementation of the api module. This module should be used when a new platform implementation is made.                                                                                     |
+| npc-lib-bukkit       | Platform specific implementation for Bukkit. This module implements the complete API (and common) to support Bukkit (and forks).                                                                      |
+| npc-lib-minestom     | Platform specific implementation for Minestom. This module implements the complete API (and common) to support Minestom (and forks).                                                                  |
+| npc-lib-fabric       | Platform specific implementation for Fabric. This module implements the complete API (and common) to support Fabric and [must be installed as a mod](https://modrinth.com/mod/npc-lib) on the server. |
+| npc-lib-labymod      | This module contains helper methods for accessing LabyMod NPC features (such as emotes and stickers). See the [LabyMod documentation](https://dev.labymod.net/) for more information.                 |
 
 ### How to include a module
 
@@ -101,6 +102,12 @@ BukkitPlatform.bukkitNpcPlatformBuilder()
 MinestomPlatform.minestomNpcPlatformBuilder()
 ```
 
+### On Fabric
+
+```java
+FabricPlatform.fabricNpcPlatformBuilder()
+```
+
 ## Configuring the Platform
 
 In all further examples bukkit will be used as a reference, but the api is the same on all other platforms:
diff --git a/build.gradle.kts b/build.gradle.kts
index ceb1b3d..e2f0b6b 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -27,6 +27,7 @@ import com.diffplug.gradle.spotless.SpotlessExtension
 plugins {
   alias(libs.plugins.spotless)
   alias(libs.plugins.nexusPublish)
+  alias(libs.plugins.fabricLoom) apply false
 }
 
 defaultTasks("clean", "build")
diff --git a/checkstyle.xml b/checkstyle.xml
index 51038bc..216d32e 100644
--- a/checkstyle.xml
+++ b/checkstyle.xml
@@ -28,7 +28,7 @@
   "https://checkstyle.org/dtds/configuration_1_3.dtd">
 <module name="Checker">
   <module name="BeforeExecutionExclusionFileFilter">
-    <property name="fileNamePattern" value="module\-info\.java$"/>
+    <property name="fileNamePattern" value="(module\-info\.java$)|(.*[\\|\/]mixins[\\|\/].*$)"/>
   </module>
   <module name="SuppressionFilter">
     <property default="checkstyle-suppressions.xml" name="file"
diff --git a/fabric/build.gradle.kts b/fabric/build.gradle.kts
new file mode 100644
index 0000000..e842db0
--- /dev/null
+++ b/fabric/build.gradle.kts
@@ -0,0 +1,70 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2025 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+plugins {
+  alias(libs.plugins.fabricLoom)
+}
+
+configurations {
+  // custom configuration for later dependency resolution
+  create("runtimeImpl") {
+    configurations.getByName("api").extendsFrom(this)
+  }
+}
+
+dependencies {
+  minecraft(libs.minecraft)
+  modImplementation(libs.fabricLoader)
+  mappings(loom.officialMojangMappings())
+
+  modImplementation(platform(libs.fabricApiBom))
+  modImplementation(libs.fabricApiNetworkingV1)
+
+  "runtimeImpl"(projects.npcLibApi)
+  "runtimeImpl"(projects.npcLibCommon)
+
+  implementation(libs.geantyref)
+}
+
+tasks.withType<Jar> {
+  dependsOn(":npc-lib-api:jar")
+  dependsOn(":npc-lib-common:jar")
+  from(configurations.getByName("runtimeImpl").map { if (it.isDirectory) it else zipTree(it) })
+}
+
+tasks.withType<JavaCompile> {
+  options.release.set(21)
+}
+
+tasks.withType<ProcessResources> {
+  val props = mapOf("version" to project.version)
+  inputs.properties(props)
+  filesMatching("fabric.mod.json") {
+    expand(props)
+  }
+}
+
+loom {
+  accessWidenerPath.set(project.file("src/main/resources/npc_lib.accesswidener"))
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricModInitializer.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricModInitializer.java
new file mode 100644
index 0000000..9c924c0
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricModInitializer.java
@@ -0,0 +1,35 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric;
+
+import net.fabricmc.api.ModInitializer;
+
+public final class FabricModInitializer implements ModInitializer {
+
+  @Override
+  public void onInitialize() {
+
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricPlatform.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricPlatform.java
new file mode 100644
index 0000000..da8bdcd
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricPlatform.java
@@ -0,0 +1,101 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric;
+
+import com.github.juliarn.npclib.api.NpcActionController;
+import com.github.juliarn.npclib.api.Platform;
+import com.github.juliarn.npclib.common.platform.CommonPlatform;
+import com.github.juliarn.npclib.common.platform.CommonPlatformBuilder;
+import com.github.juliarn.npclib.fabric.controller.FabricActionController;
+import com.github.juliarn.npclib.fabric.protocol.FabricProtocolAdapter;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.item.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+public final class FabricPlatform extends CommonPlatformBuilder<ServerLevel, ServerPlayer, ItemStack, Object> {
+
+  private FabricPlatform() {
+  }
+
+  public static @NotNull Platform.Builder<ServerLevel, ServerPlayer, ItemStack, Object> fabricNpcPlatformBuilder() {
+    return new FabricPlatform();
+  }
+
+  @Override
+  protected void prepareBuild() {
+    // set the default task manager
+    if (this.taskManager == null) {
+      this.taskManager = FabricPlatformTaskManager.taskManager();
+    }
+
+    // set the default version accessor
+    if (this.versionAccessor == null) {
+      this.versionAccessor = FabricVersionAccessor.versionNameBased();
+    }
+
+    // set the default world accessor
+    if (this.worldAccessor == null) {
+      this.worldAccessor = FabricWorldAccessor.keyBased();
+    }
+
+    // set the default packet adapter
+    if (this.packetAdapter == null) {
+      this.packetAdapter = FabricProtocolAdapter.fabricProtocolAdapter();
+    }
+
+    // set the default logger if no logger was provided
+    if (this.logger == null) {
+      this.logger = FabricPlatformLogger.logger();
+    }
+  }
+
+  @Override
+  protected @NotNull Platform<ServerLevel, ServerPlayer, ItemStack, Object> doBuild() {
+    // check if we need an action controller
+    NpcActionController actionController = null;
+    if (this.actionControllerDecorator != null) {
+      NpcActionController.Builder builder = FabricActionController.actionControllerBuilder(
+        this.eventManager,
+        this.npcTracker);
+      this.actionControllerDecorator.accept(builder);
+      actionController = builder.build();
+    }
+
+    // build the platform
+    return new CommonPlatform<>(
+      this.debug,
+      this.extension,
+      this.logger,
+      this.npcTracker,
+      this.profileResolver,
+      this.taskManager,
+      actionController,
+      this.versionAccessor,
+      this.eventManager,
+      this.worldAccessor,
+      this.packetAdapter);
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricPlatformLogger.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricPlatformLogger.java
new file mode 100644
index 0000000..eb93576
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricPlatformLogger.java
@@ -0,0 +1,64 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric;
+
+import com.github.juliarn.npclib.api.log.PlatformLogger;
+import com.mojang.logging.LogUtils;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+
+public final class FabricPlatformLogger implements PlatformLogger {
+
+  private static final Logger LOGGER = LogUtils.getLogger();
+  private static final FabricPlatformLogger INSTANCE = new FabricPlatformLogger();
+
+  private FabricPlatformLogger() {
+  }
+
+  public static @NotNull PlatformLogger logger() {
+    return INSTANCE;
+  }
+
+  @Override
+  public void info(@NotNull String message) {
+    LOGGER.info(message);
+  }
+
+  @Override
+  public void warning(@NotNull String message) {
+    LOGGER.warn(message);
+  }
+
+  @Override
+  public void error(@NotNull String message) {
+    LOGGER.error(message);
+  }
+
+  @Override
+  public void error(@NotNull String message, @Nullable Throwable exception) {
+    LOGGER.error(message, exception);
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricPlatformTaskManager.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricPlatformTaskManager.java
new file mode 100644
index 0000000..aaebfc5
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricPlatformTaskManager.java
@@ -0,0 +1,53 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric;
+
+import com.github.juliarn.npclib.api.PlatformTaskManager;
+import com.github.juliarn.npclib.common.task.AsyncPlatformTaskManager;
+import com.github.juliarn.npclib.fabric.util.FabricUtil;
+import org.jetbrains.annotations.NotNull;
+
+public final class FabricPlatformTaskManager extends AsyncPlatformTaskManager {
+
+  private static final FabricPlatformTaskManager INSTANCE = new FabricPlatformTaskManager();
+
+  private FabricPlatformTaskManager() {
+    super("Fabric");
+  }
+
+  public static @NotNull PlatformTaskManager taskManager() {
+    return INSTANCE;
+  }
+
+  @Override
+  public void scheduleSync(@NotNull Runnable task) {
+    FabricUtil.getServer().execute(task);
+  }
+
+  @Override
+  public void scheduleDelayedSync(@NotNull Runnable task, int delayTicks) {
+    throw new UnsupportedOperationException("not implemented on fabric platform");
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricVersionAccessor.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricVersionAccessor.java
new file mode 100644
index 0000000..b537766
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricVersionAccessor.java
@@ -0,0 +1,85 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric;
+
+import com.github.juliarn.npclib.api.PlatformVersionAccessor;
+import net.minecraft.SharedConstants;
+import org.jetbrains.annotations.NotNull;
+
+public final class FabricVersionAccessor {
+
+  private static int[] extractServerVersionParts() {
+    String[] parts = SharedConstants.getCurrentVersion().getName().split("\\.");
+    if (parts.length == 2 || parts.length == 3) {
+      // should be in the correct format, just to make sure
+      try {
+        int major = Integer.parseInt(parts[0]);
+        int minor = Integer.parseInt(parts[1]);
+        int patch = parts.length == 3 ? Integer.parseInt(parts[2]) : 0;
+
+        // return the version array from that
+        return new int[]{major, minor, patch};
+      } catch (NumberFormatException ignored) {
+      }
+    }
+
+    // unable to parse
+    return new int[0];
+  }
+
+  public static @NotNull PlatformVersionAccessor versionNameBased() {
+    return FabricVersionNameAccessor.INSTANCE;
+  }
+
+  private static final class FabricVersionNameAccessor implements PlatformVersionAccessor {
+
+    private static final int[] VERSION_NUMBER_PARTS = extractServerVersionParts();
+    private static final FabricVersionNameAccessor INSTANCE = new FabricVersionNameAccessor();
+
+    private static int safeGetPart(int index, int def) {
+      return VERSION_NUMBER_PARTS.length > index ? VERSION_NUMBER_PARTS[index] : def;
+    }
+
+    @Override
+    public int major() {
+      return safeGetPart(0, 1);
+    }
+
+    @Override
+    public int minor() {
+      return safeGetPart(1, 0);
+    }
+
+    @Override
+    public int patch() {
+      return safeGetPart(2, 0);
+    }
+
+    @Override
+    public boolean atLeast(int major, int minor, int patch) {
+      return this.major() >= major && this.minor() >= major && this.patch() >= patch;
+    }
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricWorldAccessor.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricWorldAccessor.java
new file mode 100644
index 0000000..769b61c
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/FabricWorldAccessor.java
@@ -0,0 +1,61 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric;
+
+import com.github.juliarn.npclib.api.PlatformWorldAccessor;
+import com.github.juliarn.npclib.fabric.util.FabricUtil;
+import net.minecraft.server.level.ServerLevel;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public final class FabricWorldAccessor {
+
+  public static @NotNull PlatformWorldAccessor<ServerLevel> keyBased() {
+    return KeyBasedLevelAccessor.INSTANCE;
+  }
+
+  private static final class KeyBasedLevelAccessor implements PlatformWorldAccessor<ServerLevel> {
+
+    private static final KeyBasedLevelAccessor INSTANCE = new KeyBasedLevelAccessor();
+
+    @Override
+    public @NotNull String extractWorldIdentifier(@NotNull ServerLevel world) {
+      return world.dimension().location().toString();
+    }
+
+    @Override
+    public @Nullable ServerLevel resolveWorldFromIdentifier(@NotNull String identifier) {
+      var levels = FabricUtil.getServer().getAllLevels();
+      for (var level : levels) {
+        var levelIdentifier = this.extractWorldIdentifier(level);
+        if (levelIdentifier.equals(identifier)) {
+          return level;
+        }
+      }
+
+      return null;
+    }
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/controller/FabricActionController.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/controller/FabricActionController.java
new file mode 100644
index 0000000..2cb64e5
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/controller/FabricActionController.java
@@ -0,0 +1,220 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric.controller;
+
+import com.github.juliarn.npclib.api.Npc;
+import com.github.juliarn.npclib.api.NpcActionController;
+import com.github.juliarn.npclib.api.NpcTracker;
+import com.github.juliarn.npclib.api.event.ShowNpcEvent;
+import com.github.juliarn.npclib.api.event.manager.NpcEventManager;
+import com.github.juliarn.npclib.api.flag.NpcFlag;
+import com.github.juliarn.npclib.api.protocol.enums.EntityAnimation;
+import com.github.juliarn.npclib.api.protocol.meta.EntityMetadataFactory;
+import com.github.juliarn.npclib.common.CommonNpcActionController;
+import com.github.juliarn.npclib.common.flag.CommonNpcFlaggedBuilder;
+import com.github.juliarn.npclib.fabric.util.FabricUtil;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.phys.Vec2;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@ApiStatus.Internal
+public final class FabricActionController extends CommonNpcActionController {
+
+  private final NpcTracker<ServerLevel, ServerPlayer, ItemStack, Object> npcTracker;
+
+  // based on the given flags
+  private final int spawnDistance;
+  private final int imitateDistance;
+
+  public FabricActionController(
+    @NotNull Map<NpcFlag<?>, Optional<?>> flags,
+    @NotNull NpcEventManager eventManager,
+    @NotNull NpcTracker<ServerLevel, ServerPlayer, ItemStack, Object> tracker
+  ) {
+    super(flags);
+    this.npcTracker = tracker;
+
+    // pre-calculate flag values
+    var spawnDistance = this.flagValueOrDefault(SPAWN_DISTANCE);
+    this.spawnDistance = spawnDistance * spawnDistance;
+
+    var imitateDistance = this.flagValueOrDefault(IMITATE_DISTANCE);
+    this.imitateDistance = imitateDistance * imitateDistance;
+
+    // register listener to update the npc rotation after it is tracked
+    if (this.flagValueOrDefault(NpcActionController.AUTO_SYNC_POSITION_ON_SPAWN)) {
+      eventManager.registerEventHandler(ShowNpcEvent.Post.class, event -> {
+        ServerPlayer player = event.player();
+        var pos = player.position();
+        var rot = player.getRotationVector();
+        var level = player.serverLevel();
+
+        double distance = FabricUtil.distance(event.npc(), pos);
+        if (distance <= this.imitateDistance && event.npc().flagValueOrDefault(Npc.LOOK_AT_PLAYER)) {
+          var playerPos = FabricUtil.positionFromPosAndRot(level, pos, rot);
+          event.npc().lookAt(playerPos).schedule(player);
+        }
+      });
+    }
+
+    // register listeners to handle player actions
+    FabricActionControllerEvents.SERVER_PLAYER_MOVE.register(this::handleMove);
+    FabricActionControllerEvents.SERVER_PLAYER_DISCONNECT.register(this::handleQuit);
+    FabricActionControllerEvents.SERVER_PLAYER_TOGGLE_SNEAK.register(this::handleToggleSneak);
+    FabricActionControllerEvents.SERVER_PLAYER_HAND_SWING.register(this::handlePlayerHandSwing);
+    FabricActionControllerEvents.SERVER_PLAYER_LEVEL_CHANGE.register(this::handleLevelChange);
+  }
+
+  public static @NotNull NpcActionController.Builder actionControllerBuilder(
+    @NotNull NpcEventManager eventManager,
+    @NotNull NpcTracker<ServerLevel, ServerPlayer, ItemStack, Object> npcTracker
+  ) {
+    Objects.requireNonNull(eventManager, "eventManager");
+    Objects.requireNonNull(npcTracker, "npcTracker");
+
+    return new FabricActionControllerBuilder(eventManager, npcTracker);
+  }
+
+  private void handleMove(@NotNull ServerPlayer player, @Nullable Vec3 pos, @Nullable Vec2 rot) {
+    for (var npc : this.npcTracker.trackedNpcs()) {
+      // check if the player is still in the same world as the npc
+      var npcPos = npc.position();
+      var level = player.serverLevel();
+      if (!npc.world().equals(level) || !npc.world().hasChunk(npcPos.chunkX(), npcPos.chunkZ())) {
+        // if the player is tracked by the npc, stop that
+        npc.stopTrackingPlayer(player);
+        continue;
+      }
+
+      // check if the player moved in / out of any npc tracking distance
+      var playerPos = Objects.requireNonNullElse(pos, player.position());
+      var distance = FabricUtil.distance(npc, playerPos);
+      if (distance > this.spawnDistance) {
+        // this will only do something if the player is already tracked by the npc
+        npc.stopTrackingPlayer(player);
+        continue;
+      } else {
+        // this will only do something if the player is not already tracked by the npc
+        npc.trackPlayer(player);
+      }
+
+      // check if we should rotate the npc towards the player
+      if (rot != null
+        && npc.tracksPlayer(player)
+        && distance <= this.imitateDistance
+        && npc.flagValueOrDefault(Npc.LOOK_AT_PLAYER)) {
+        var playerPosition = FabricUtil.positionFromPosAndRot(level, playerPos, rot);
+        npc.lookAt(playerPosition).schedule(player);
+      }
+    }
+  }
+
+  private void handleLevelChange(
+    @NotNull ServerPlayer player,
+    @Nullable ServerLevel oldLevel,
+    @NotNull ServerLevel newLevel
+  ) {
+    // ensure that we stop tracking the player on NPCs which are not in the same world as the player
+    for (var npc : this.npcTracker.trackedNpcs()) {
+      if (!npc.world().equals(player.serverLevel())) {
+        // the player is no longer in the same world, stop tracking
+        npc.stopTrackingPlayer(player);
+        continue;
+      }
+
+      // the player is now in the same instance as the npc, check if we should track him
+      var distance = FabricUtil.distance(npc, player.position());
+      if (this.spawnDistance >= distance) {
+        npc.trackPlayer(player);
+      }
+    }
+  }
+
+  private void handleToggleSneak(@NotNull ServerPlayer player, boolean sneaking) {
+    for (var npc : this.npcTracker.trackedNpcs()) {
+      // check if we should imitate the action
+      var distance = FabricUtil.distance(npc, player.position());
+      if (npc.world().equals(player.serverLevel())
+        && npc.tracksPlayer(player)
+        && distance <= this.imitateDistance
+        && npc.flagValueOrDefault(Npc.SNEAK_WHEN_PLAYER_SNEAKS)) {
+        // let the npc sneak as well
+        npc.platform().packetFactory()
+          .createEntityMetaPacket(EntityMetadataFactory.sneakingMetaFactory(), sneaking)
+          .schedule(player, npc);
+      }
+    }
+  }
+
+  private void handlePlayerHandSwing(@NotNull ServerPlayer player) {
+    for (var npc : this.npcTracker.trackedNpcs()) {
+      // check if we should imitate the action
+      var distance = FabricUtil.distance(npc, player.position());
+      if (npc.world().equals(player.serverLevel())
+        && npc.tracksPlayer(player)
+        && distance <= this.imitateDistance
+        && npc.flagValueOrDefault(Npc.HIT_WHEN_PLAYER_HITS)) {
+        // let the npc left click as well
+        npc.platform().packetFactory().createAnimationPacket(EntityAnimation.SWING_MAIN_ARM).schedule(player, npc);
+      }
+    }
+  }
+
+  private void handleQuit(@NotNull ServerPlayer player) {
+    for (var npc : this.npcTracker.trackedNpcs()) {
+      // check if the npc tracks the player which disconnected and stop tracking him if so
+      npc.stopTrackingPlayer(player);
+    }
+  }
+
+  private static final class FabricActionControllerBuilder
+    extends CommonNpcFlaggedBuilder<Builder>
+    implements NpcActionController.Builder {
+
+    private final NpcEventManager eventManager;
+    private final NpcTracker<ServerLevel, ServerPlayer, ItemStack, Object> npcTracker;
+
+    public FabricActionControllerBuilder(
+      @NotNull NpcEventManager eventManager,
+      @NotNull NpcTracker<ServerLevel, ServerPlayer, ItemStack, Object> npcTracker
+    ) {
+      this.eventManager = eventManager;
+      this.npcTracker = npcTracker;
+    }
+
+    @Override
+    public @NotNull NpcActionController build() {
+      return new FabricActionController(this.flags, this.eventManager, this.npcTracker);
+    }
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/controller/FabricActionControllerEvents.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/controller/FabricActionControllerEvents.java
new file mode 100644
index 0000000..80ecfe2
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/controller/FabricActionControllerEvents.java
@@ -0,0 +1,161 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric.controller;
+
+import net.fabricmc.fabric.api.event.Event;
+import net.fabricmc.fabric.api.event.EventFactory;
+import net.minecraft.network.protocol.game.ServerboundInteractPacket;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.phys.Vec2;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Internal event for notifying the action controller about player actions.
+ */
+@ApiStatus.Internal
+public interface FabricActionControllerEvents {
+
+  Event<ServerPlayerLevelChange> SERVER_PLAYER_LEVEL_CHANGE = EventFactory.createArrayBacked(
+    ServerPlayerLevelChange.class,
+    callbacks -> (player, oldLevel, newLevel) -> {
+      for (var callback : callbacks) {
+        callback.levelChange(player, oldLevel, newLevel);
+      }
+    }
+  );
+
+  Event<ServerPlayerToggleSneak> SERVER_PLAYER_TOGGLE_SNEAK = EventFactory.createArrayBacked(
+    ServerPlayerToggleSneak.class,
+    callbacks -> (player, sneak) -> {
+      for (var callback : callbacks) {
+        callback.toggleSneak(player, sneak);
+      }
+    }
+  );
+
+  Event<ServerPlayerHandSwing> SERVER_PLAYER_HAND_SWING = EventFactory.createArrayBacked(
+    ServerPlayerHandSwing.class,
+    callbacks -> player -> {
+      for (var callback : callbacks) {
+        callback.swingHand(player);
+      }
+    }
+  );
+
+  Event<ServerPlayerDisconnect> SERVER_PLAYER_DISCONNECT = EventFactory.createArrayBacked(
+    ServerPlayerDisconnect.class,
+    callbacks -> player -> {
+      for (var callback : callbacks) {
+        callback.disconnect(player);
+      }
+    }
+  );
+
+  Event<ServerPlayerMove> SERVER_PLAYER_MOVE = EventFactory.createArrayBacked(
+    ServerPlayerMove.class,
+    callbacks -> (player, posTo, rotTo) -> {
+      for (var callback : callbacks) {
+        callback.move(player, posTo, rotTo);
+      }
+    }
+  );
+
+  Event<ServerPlayerEntityInteract> SERVER_PLAYER_ENTITY_INTERACT = EventFactory.createArrayBacked(
+    ServerPlayerEntityInteract.class,
+    callbacks -> (entityId, player, actionType, hand) -> {
+      for (var callback : callbacks) {
+        if (callback.interact(entityId, player, actionType, hand)) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+  );
+
+  /**
+   * Called before a server player changes the level.
+   */
+  @FunctionalInterface
+  interface ServerPlayerLevelChange {
+
+    void levelChange(@NotNull ServerPlayer player, @Nullable ServerLevel oldLevel, @NotNull ServerLevel newLevel);
+  }
+
+  /**
+   * Called when a server player starts or stops sprinting.
+   */
+  @FunctionalInterface
+  interface ServerPlayerToggleSneak {
+
+    void toggleSneak(@NotNull ServerPlayer player, boolean sneaking);
+  }
+
+  /**
+   * Called when a server player swings his hand (left click).
+   */
+  @FunctionalInterface
+  interface ServerPlayerHandSwing {
+
+    void swingHand(@NotNull ServerPlayer player);
+  }
+
+  /**
+   * Called when a server player disconnects.
+   */
+  @FunctionalInterface
+  interface ServerPlayerDisconnect {
+
+    void disconnect(@NotNull ServerPlayer player);
+  }
+
+  /**
+   * Called when a server player moves. Note that the pos and rot is only given if it was changed by the client.
+   */
+  @FunctionalInterface
+  interface ServerPlayerMove {
+
+    void move(@NotNull ServerPlayer player, @Nullable Vec3 posTo, @Nullable Vec2 rotTo);
+  }
+
+  /**
+   * Called when a server player interacts with an entity (interact or attack). If one listener returns true, all
+   * subsequent listeners are cancelled and the packet processing gets aborted.
+   */
+  @FunctionalInterface
+  interface ServerPlayerEntityInteract {
+
+    boolean interact(
+      int entityId,
+      @NotNull ServerPlayer player,
+      @NotNull ServerboundInteractPacket.ActionType actionType,
+      @NotNull InteractionHand hand);
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/MinecraftServerMixin.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/MinecraftServerMixin.java
new file mode 100644
index 0000000..012909d
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/MinecraftServerMixin.java
@@ -0,0 +1,41 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric.mixins;
+
+import com.github.juliarn.npclib.fabric.util.FabricUtil;
+import net.minecraft.server.MinecraftServer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(MinecraftServer.class)
+abstract class MinecraftServerMixin {
+
+  @Inject(method = "loadLevel", at = @At("HEAD"))
+  public void npc_lib$loadLevel(CallbackInfo ci) {
+    FabricUtil.setServer((MinecraftServer) (Object) this);
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/PlayerListMixin.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/PlayerListMixin.java
new file mode 100644
index 0000000..6312bc3
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/PlayerListMixin.java
@@ -0,0 +1,57 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric.mixins;
+
+import com.github.juliarn.npclib.fabric.controller.FabricActionControllerEvents;
+import net.minecraft.network.Connection;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.network.CommonListenerCookie;
+import net.minecraft.server.players.PlayerList;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(PlayerList.class)
+public abstract class PlayerListMixin {
+
+  @Inject(method = "remove", at = @At("TAIL"))
+  public void npc_lib$remove(ServerPlayer player, CallbackInfo ci) {
+    var invoker = FabricActionControllerEvents.SERVER_PLAYER_DISCONNECT.invoker();
+    invoker.disconnect(player);
+  }
+
+  @Inject(method = "placeNewPlayer", at = @At("TAIL"))
+  public void npc_lib$placeNewPlayer(
+    Connection connection,
+    ServerPlayer serverPlayer,
+    CommonListenerCookie commonListenerCookie,
+    CallbackInfo ci
+  ) {
+    var newLevel = serverPlayer.serverLevel();
+    var invoker = FabricActionControllerEvents.SERVER_PLAYER_LEVEL_CHANGE.invoker();
+    invoker.levelChange(serverPlayer, null, newLevel);
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/ServerGamePacketListenerImplMixin.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/ServerGamePacketListenerImplMixin.java
new file mode 100644
index 0000000..78d3922
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/ServerGamePacketListenerImplMixin.java
@@ -0,0 +1,169 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric.mixins;
+
+import com.github.juliarn.npclib.fabric.controller.FabricActionControllerEvents;
+import net.minecraft.network.protocol.game.ServerboundInteractPacket;
+import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
+import net.minecraft.network.protocol.game.ServerboundMoveVehiclePacket;
+import net.minecraft.network.protocol.game.ServerboundPlayerCommandPacket;
+import net.minecraft.network.protocol.game.ServerboundSwingPacket;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.network.ServerGamePacketListenerImpl;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.phys.Vec2;
+import net.minecraft.world.phys.Vec3;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Slice;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ServerGamePacketListenerImpl.class)
+public abstract class ServerGamePacketListenerImplMixin {
+
+  @Shadow
+  public ServerPlayer player;
+
+  @Shadow
+  public abstract ServerPlayer getPlayer();
+
+  @Inject(method = "handlePlayerCommand", at = @At("TAIL"))
+  public void npc_lib$handlePlayerCommand(ServerboundPlayerCommandPacket packet, CallbackInfo ci) {
+    var player = this.getPlayer();
+    var command = packet.getAction();
+    if (command == ServerboundPlayerCommandPacket.Action.PRESS_SHIFT_KEY
+      || command == ServerboundPlayerCommandPacket.Action.RELEASE_SHIFT_KEY) {
+      var invoker = FabricActionControllerEvents.SERVER_PLAYER_TOGGLE_SNEAK.invoker();
+      var sprintStarted = command == ServerboundPlayerCommandPacket.Action.PRESS_SHIFT_KEY;
+      invoker.toggleSneak(player, sprintStarted);
+    }
+  }
+
+  @Inject(method = "handleAnimate", at = @At("TAIL"))
+  public void npc_lib$handleAnimate(ServerboundSwingPacket packet, CallbackInfo ci) {
+    var player = this.getPlayer();
+    var invoker = FabricActionControllerEvents.SERVER_PLAYER_HAND_SWING.invoker();
+    invoker.swingHand(player);
+  }
+
+  @Inject(
+    method = "handleMovePlayer",
+    at = @At(
+      value = "INVOKE",
+      target = "Lnet/minecraft/network/protocol/game/ServerboundMovePlayerPacket;getYRot(F)F"
+    ),
+    slice = @Slice(
+      from = @At(value = "INVOKE", target = "Lnet/minecraft/server/network/ServerGamePacketListenerImpl;updateAwaitingTeleport()Z"),
+      to = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerPlayer;isPassenger()Z")
+    )
+  )
+  public void npc_lib$handleMovePlayer(ServerboundMovePlayerPacket packet, CallbackInfo ci) {
+    // ensure that the packet contains at least position and rotation
+    var hasPos = packet.hasPosition();
+    var hasRot = packet.hasRotation();
+    if (!hasPos && !hasRot) {
+      return;
+    }
+
+    // get the new target position, null in case it's not provided by the packet
+    var player = this.getPlayer();
+    var posToX = packet.getX(player.getX());
+    var posToY = packet.getY(player.getY());
+    var posToZ = packet.getZ(player.getZ());
+    var posTo = hasPos ? new Vec3(posToX, posToY, posToZ) : null;
+
+    // get the new target rotation, null in case it's not provided by the packet
+    var rotToX = packet.getXRot(player.getXRot());
+    var rotToY = packet.getYRot(player.getYRot());
+    var rotTo = hasRot ? new Vec2(rotToX, rotToY) : null;
+
+    // invoke the player move event
+    var invoker = FabricActionControllerEvents.SERVER_PLAYER_MOVE.invoker();
+    invoker.move(player, posTo, rotTo);
+  }
+
+  @Inject(
+    method = "handleMoveVehicle",
+    at = @At(
+      value = "INVOKE",
+      target = "Lnet/minecraft/world/entity/Entity;getControllingPassenger()Lnet/minecraft/world/entity/LivingEntity;"
+    )
+  )
+  public void npc_lib$handleMoveVehicle(ServerboundMoveVehiclePacket packet, CallbackInfo ci) {
+    var player = this.getPlayer();
+    var rootVehicle = player.getRootVehicle();
+
+    // get the target position, set to null in case it didn't change
+    var posFrom = rootVehicle.position();
+    var posTo = packet.position();
+    if (posTo.equals(posFrom)) {
+      posTo = null;
+    }
+
+    // get the target rotation, set to null in case it didn't change
+    var rotFrom = rootVehicle.getRotationVector();
+    var rotTo = new Vec2(packet.xRot(), packet.yRot());
+    if (rotTo.equals(rotFrom)) {
+      rotTo = null;
+    }
+
+    // fire player move event in case position or rotation changed
+    if (posTo != null || rotTo != null) {
+      var invoker = FabricActionControllerEvents.SERVER_PLAYER_MOVE.invoker();
+      invoker.move(player, posTo, rotTo);
+    }
+  }
+
+  @Inject(
+    method = "handleInteract",
+    at = @At(
+      value = "INVOKE",
+      shift = At.Shift.AFTER,
+      target = "Lnet/minecraft/server/level/ServerPlayer;setShiftKeyDown(Z)V"
+    ),
+    cancellable = true
+  )
+  public void npc_lib$handleInteract(ServerboundInteractPacket packet, CallbackInfo ci) {
+    var player = this.getPlayer();
+    var invoker = FabricActionControllerEvents.SERVER_PLAYER_ENTITY_INTERACT.invoker();
+
+    // call the interact event if the action is either interact or attack
+    var action = packet.action;
+    var actionType = action.getType();
+    if (action instanceof ServerboundInteractPacket.InteractionAction interactionAction) {
+      var hand = interactionAction.hand;
+      if (invoker.interact(packet.entityId, player, ServerboundInteractPacket.ActionType.INTERACT, hand)) {
+        ci.cancel();
+      }
+    } else if (actionType == ServerboundInteractPacket.ActionType.ATTACK) {
+      var hand = InteractionHand.MAIN_HAND;
+      if (invoker.interact(packet.entityId, player, ServerboundInteractPacket.ActionType.ATTACK, hand)) {
+        ci.cancel();
+      }
+    }
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/ServerPlayerMixin.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/ServerPlayerMixin.java
new file mode 100644
index 0000000..685e063
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/mixins/ServerPlayerMixin.java
@@ -0,0 +1,51 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric.mixins;
+
+import com.github.juliarn.npclib.fabric.controller.FabricActionControllerEvents;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ServerPlayer.class)
+public abstract class ServerPlayerMixin {
+
+  @Shadow
+  public abstract ServerLevel serverLevel();
+
+  @Inject(method = "setServerLevel", at = @At("HEAD"))
+  public void npc_lib$setServerLevel(ServerLevel level, CallbackInfo ci) {
+    var currentLevel = this.serverLevel();
+    var player = (ServerPlayer) (Object) this;
+    if (currentLevel != null && player.connection != null) {
+      var eventInvoker = FabricActionControllerEvents.SERVER_PLAYER_LEVEL_CHANGE.invoker();
+      eventInvoker.levelChange(player, currentLevel, level);
+    }
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/protocol/ByteArrayCustomPayload.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/protocol/ByteArrayCustomPayload.java
new file mode 100644
index 0000000..84c9e2f
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/protocol/ByteArrayCustomPayload.java
@@ -0,0 +1,43 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric.protocol;
+
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import org.jetbrains.annotations.NotNull;
+
+record ByteArrayCustomPayload(
+  @NotNull Type<ByteArrayCustomPayload> type,
+  byte[] payloadContent
+) implements CustomPacketPayload {
+
+  static final StreamCodec<RegistryFriendlyByteBuf, ByteArrayCustomPayload> CODEC = CustomPacketPayload.codec(
+    (payload, buf) -> buf.writeBytes(payload.payloadContent()),
+    buf -> {
+      throw new UnsupportedOperationException("decode not supported");
+    }
+  );
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/protocol/EntityDataFactory.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/protocol/EntityDataFactory.java
new file mode 100644
index 0000000..bcac375
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/protocol/EntityDataFactory.java
@@ -0,0 +1,34 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric.protocol;
+
+import net.minecraft.network.syncher.SynchedEntityData;
+import org.jetbrains.annotations.NotNull;
+
+@FunctionalInterface
+interface EntityDataFactory {
+
+  @NotNull SynchedEntityData.DataValue<?> create(int index, @NotNull Object value);
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/protocol/FabricProtocolAdapter.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/protocol/FabricProtocolAdapter.java
new file mode 100644
index 0000000..2a5895f
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/protocol/FabricProtocolAdapter.java
@@ -0,0 +1,404 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric.protocol;
+
+import com.github.juliarn.npclib.api.Platform;
+import com.github.juliarn.npclib.api.event.InteractNpcEvent;
+import com.github.juliarn.npclib.api.protocol.OutboundPacket;
+import com.github.juliarn.npclib.api.protocol.PlatformPacketAdapter;
+import com.github.juliarn.npclib.api.protocol.enums.EntityAnimation;
+import com.github.juliarn.npclib.api.protocol.enums.EntityPose;
+import com.github.juliarn.npclib.api.protocol.enums.ItemSlot;
+import com.github.juliarn.npclib.api.protocol.enums.PlayerInfoAction;
+import com.github.juliarn.npclib.api.protocol.meta.EntityMetadataFactory;
+import com.github.juliarn.npclib.common.event.DefaultAttackNpcEvent;
+import com.github.juliarn.npclib.common.event.DefaultInteractNpcEvent;
+import com.github.juliarn.npclib.fabric.controller.FabricActionControllerEvents;
+import com.github.juliarn.npclib.fabric.util.FabricUtil;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import com.mojang.datafixers.util.Pair;
+import io.leangen.geantyref.TypeFactory;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.UnaryOperator;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.fabricmc.fabric.impl.networking.PayloadTypeRegistryImpl;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.network.protocol.game.ClientboundAddEntityPacket;
+import net.minecraft.network.protocol.game.ClientboundAnimatePacket;
+import net.minecraft.network.protocol.game.ClientboundMoveEntityPacket;
+import net.minecraft.network.protocol.game.ClientboundPlayerInfoRemovePacket;
+import net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket;
+import net.minecraft.network.protocol.game.ClientboundRemoveEntitiesPacket;
+import net.minecraft.network.protocol.game.ClientboundRotateHeadPacket;
+import net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket;
+import net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket;
+import net.minecraft.network.syncher.EntityDataSerializers;
+import net.minecraft.network.syncher.SynchedEntityData;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.util.Mth;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.Pose;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.GameType;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
+
+public final class FabricProtocolAdapter
+  implements PlatformPacketAdapter<ServerLevel, ServerPlayer, ItemStack, Object> {
+
+  private static final FabricProtocolAdapter INSTANCE = new FabricProtocolAdapter();
+
+  private static final Type OPTIONAL_CHAT_COMPONENT_TYPE = TypeFactory.parameterizedClass(
+    Optional.class,
+    net.minecraft.network.chat.Component.class);
+
+  private static final EnumMap<EntityPose, Pose> ENTITY_POSE_CONVERTER;
+  private static final EnumMap<ItemSlot, EquipmentSlot> ITEM_SLOT_CONVERTER;
+  private static final EnumMap<InteractionHand, InteractNpcEvent.Hand> HAND_CONVERTER;
+
+  private static final Map<Type, EntityDataFactory> META_ENTRY_FACTORY;
+  private static final Map<Type, Map.Entry<Type, UnaryOperator<Object>>> SERIALIZER_CONVERTERS;
+
+  private static final EnumSet<ClientboundPlayerInfoUpdatePacket.Action> ADD_ACTIONS = EnumSet.of(
+    ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER,
+    ClientboundPlayerInfoUpdatePacket.Action.UPDATE_HAT,
+    ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED,
+    ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LATENCY,
+    ClientboundPlayerInfoUpdatePacket.Action.UPDATE_GAME_MODE,
+    ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME
+  );
+
+  static {
+    ITEM_SLOT_CONVERTER = new EnumMap<>(ItemSlot.class);
+    ITEM_SLOT_CONVERTER.put(ItemSlot.MAIN_HAND, EquipmentSlot.MAINHAND);
+    ITEM_SLOT_CONVERTER.put(ItemSlot.OFF_HAND, EquipmentSlot.OFFHAND);
+    ITEM_SLOT_CONVERTER.put(ItemSlot.FEET, EquipmentSlot.FEET);
+    ITEM_SLOT_CONVERTER.put(ItemSlot.LEGS, EquipmentSlot.LEGS);
+    ITEM_SLOT_CONVERTER.put(ItemSlot.CHEST, EquipmentSlot.CHEST);
+    ITEM_SLOT_CONVERTER.put(ItemSlot.HEAD, EquipmentSlot.HEAD);
+
+    ENTITY_POSE_CONVERTER = new EnumMap<>(EntityPose.class);
+    ENTITY_POSE_CONVERTER.put(EntityPose.STANDING, Pose.STANDING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.FALL_FLYING, Pose.FALL_FLYING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.SLEEPING, Pose.SLEEPING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.SWIMMING, Pose.SWIMMING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.SPIN_ATTACK, Pose.SPIN_ATTACK);
+    ENTITY_POSE_CONVERTER.put(EntityPose.CROUCHING, Pose.CROUCHING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.LONG_JUMPING, Pose.LONG_JUMPING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.DYING, Pose.DYING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.CROAKING, Pose.CROAKING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.USING_TONGUE, Pose.USING_TONGUE);
+    ENTITY_POSE_CONVERTER.put(EntityPose.ROARING, Pose.ROARING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.SNIFFING, Pose.SNIFFING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.EMERGING, Pose.EMERGING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.DIGGING, Pose.DIGGING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.SLIDING, Pose.SLIDING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.SHOOTING, Pose.SHOOTING);
+    ENTITY_POSE_CONVERTER.put(EntityPose.INHALING, Pose.INHALING);
+
+    HAND_CONVERTER = new EnumMap<>(InteractionHand.class);
+    HAND_CONVERTER.put(InteractionHand.MAIN_HAND, InteractNpcEvent.Hand.MAIN_HAND);
+    HAND_CONVERTER.put(InteractionHand.OFF_HAND, InteractNpcEvent.Hand.OFF_HAND);
+
+    SERIALIZER_CONVERTERS = HashMap.newHashMap(2);
+    //noinspection SuspiciousMethodCalls
+    SERIALIZER_CONVERTERS.put(EntityPose.class, Map.entry(Pose.class, ENTITY_POSE_CONVERTER::get));
+    SERIALIZER_CONVERTERS.put(
+      TypeFactory.parameterizedClass(Optional.class, com.github.juliarn.npclib.api.protocol.chat.Component.class),
+      Map.entry(
+        OPTIONAL_CHAT_COMPONENT_TYPE,
+        value -> {
+          //noinspection unchecked
+          var optionalComponent = (Optional<com.github.juliarn.npclib.api.protocol.chat.Component>) value;
+          return optionalComponent.map(component -> {
+            // build the component based on the given input
+            String rawMessage = component.rawMessage();
+            if (rawMessage != null) {
+              return Component.literal(rawMessage);
+            } else {
+              var registries = FabricUtil.getServer().registryAccess();
+              return Component.Serializer.fromJson(Objects.requireNonNull(component.encodedJsonMessage()), registries);
+            }
+          });
+        }
+      ));
+
+    META_ENTRY_FACTORY = HashMap.newHashMap(7);
+    META_ENTRY_FACTORY.put(Byte.class, (index, value) -> new SynchedEntityData.DataValue<>(
+      index,
+      EntityDataSerializers.BYTE,
+      (byte) value));
+    META_ENTRY_FACTORY.put(Integer.class, (index, value) -> new SynchedEntityData.DataValue<>(
+      index,
+      EntityDataSerializers.INT,
+      (int) value));
+    META_ENTRY_FACTORY.put(Float.class, (index, value) -> new SynchedEntityData.DataValue<>(
+      index,
+      EntityDataSerializers.FLOAT,
+      (float) value));
+    META_ENTRY_FACTORY.put(Boolean.class, (index, value) -> new SynchedEntityData.DataValue<>(
+      index,
+      EntityDataSerializers.BOOLEAN,
+      (boolean) value));
+    META_ENTRY_FACTORY.put(String.class, (index, value) -> new SynchedEntityData.DataValue<>(
+      index,
+      EntityDataSerializers.STRING,
+      (String) value));
+    META_ENTRY_FACTORY.put(Pose.class, (index, value) -> new SynchedEntityData.DataValue<>(
+      index,
+      EntityDataSerializers.POSE,
+      (Pose) value));
+    //noinspection unchecked
+    META_ENTRY_FACTORY.put(OPTIONAL_CHAT_COMPONENT_TYPE, (index, value) -> new SynchedEntityData.DataValue<>(
+      index,
+      EntityDataSerializers.OPTIONAL_COMPONENT,
+      (Optional<Component>) value));
+  }
+
+  private FabricProtocolAdapter() {
+  }
+
+  public static @NotNull PlatformPacketAdapter<ServerLevel, ServerPlayer, ItemStack, Object> fabricProtocolAdapter() {
+    return INSTANCE;
+  }
+
+  private static @NotNull SynchedEntityData.DataValue<?> createDataValue(
+    @NotNull Type type,
+    @NotNull Object value,
+    int index
+  ) {
+    // check if we need to convert the value before creating the meta object
+    var converter = SERIALIZER_CONVERTERS.get(type);
+    if (converter != null) {
+      type = converter.getKey();
+      value = converter.getValue().apply(value);
+    }
+
+    // get the meta factory which is converting the type
+    var metaFactory = META_ENTRY_FACTORY.get(type);
+    if (metaFactory == null) {
+      // unable to handle that
+      throw new IllegalArgumentException("Unsupported type: " + type);
+    }
+
+    // create the meta entry
+    return metaFactory.create(index, value);
+  }
+
+  @Override
+  public @NotNull OutboundPacket<ServerLevel, ServerPlayer, ItemStack, Object> createEntitySpawnPacket() {
+    return (player, npc) -> {
+      var pos = npc.position();
+      var packet = new ClientboundAddEntityPacket(
+        npc.entityId(),
+        npc.profile().uniqueId(),
+        pos.x(),
+        pos.y(),
+        pos.z(),
+        0F,
+        0F,
+        EntityType.PLAYER,
+        0,
+        Vec3.ZERO,
+        0F);
+      player.connection.send(packet);
+    };
+  }
+
+  @Override
+  public @NotNull OutboundPacket<ServerLevel, ServerPlayer, ItemStack, Object> createEntityRemovePacket() {
+    return (player, npc) -> {
+      var packet = new ClientboundRemoveEntitiesPacket(npc.entityId());
+      player.connection.send(packet);
+    };
+  }
+
+  @Override
+  public @NotNull OutboundPacket<ServerLevel, ServerPlayer, ItemStack, Object> createPlayerInfoPacket(
+    @NotNull PlayerInfoAction action
+  ) {
+    return (player, npc) -> {
+      var packet = switch (action) {
+        case REMOVE_PLAYER -> new ClientboundPlayerInfoRemovePacket(List.of(npc.profile().uniqueId()));
+        case ADD_PLAYER -> {
+          var profile = npc.profile();
+          var gameProfile = new GameProfile(profile.uniqueId(), profile.name());
+          for (var property : profile.properties()) {
+            var prop = new Property(property.name(), property.value(), property.signature());
+            gameProfile.getProperties().put(property.name(), prop);
+          }
+
+          var updatePacket = new ClientboundPlayerInfoUpdatePacket(ADD_ACTIONS, List.of());
+          updatePacket.entries = List.of(new ClientboundPlayerInfoUpdatePacket.Entry(
+            npc.profile().uniqueId(),
+            gameProfile,
+            false,
+            20,
+            GameType.CREATIVE,
+            null,
+            true,
+            0,
+            null));
+          yield updatePacket;
+        }
+      };
+      player.connection.send(packet);
+    };
+  }
+
+  @Override
+  public @NotNull OutboundPacket<ServerLevel, ServerPlayer, ItemStack, Object> createRotationPacket(
+    float yaw,
+    float pitch
+  ) {
+    return (player, npc) -> {
+      var headLookPacket = new ClientboundRotateHeadPacket(player, Mth.packDegrees(yaw));
+      headLookPacket.entityId = npc.entityId();
+      player.connection.send(headLookPacket);
+
+      var rotationPacket = new ClientboundMoveEntityPacket.Rot(
+        npc.entityId(),
+        Mth.packDegrees(yaw),
+        Mth.packDegrees(pitch),
+        true);
+      player.connection.send(rotationPacket);
+    };
+  }
+
+  @Override
+  public @NotNull OutboundPacket<ServerLevel, ServerPlayer, ItemStack, Object> createAnimationPacket(
+    @NotNull EntityAnimation animation
+  ) {
+    return (player, npc) -> {
+      var packet = new ClientboundAnimatePacket(player, animation.id());
+      packet.id = npc.entityId();
+      player.connection.send(packet);
+    };
+  }
+
+  @Override
+  public @NotNull OutboundPacket<ServerLevel, ServerPlayer, ItemStack, Object> createEquipmentPacket(
+    @NotNull ItemSlot slot,
+    @NotNull ItemStack item
+  ) {
+    return (player, npc) -> {
+      var equipmentSlot = ITEM_SLOT_CONVERTER.get(slot);
+      var items = List.of(Pair.of(equipmentSlot, item));
+      var packet = new ClientboundSetEquipmentPacket(npc.entityId(), items);
+      player.connection.send(packet);
+    };
+  }
+
+  @Override
+  @SuppressWarnings("UnstableApiUsage")
+  public @NotNull OutboundPacket<ServerLevel, ServerPlayer, ItemStack, Object> createCustomPayloadPacket(
+    @NotNull String channelId,
+    byte[] payload
+  ) {
+    return (player, npc) -> {
+      // construct the custom payload to send
+      var channelLocation = ResourceLocation.parse(channelId);
+      var payloadType = new CustomPacketPayload.Type<ByteArrayCustomPayload>(channelLocation);
+      var customPayload = new ByteArrayCustomPayload(payloadType, payload);
+
+      // ensure that the payload codec is registered for the payload type
+      var payloadTypeRegistry = PayloadTypeRegistryImpl.PLAY_S2C;
+      var registered = payloadTypeRegistry.get(channelLocation);
+      if (registered == null) {
+        payloadTypeRegistry.register(payloadType, ByteArrayCustomPayload.CODEC);
+      }
+
+      ServerPlayNetworking.send(player, customPayload);
+    };
+  }
+
+  @Override
+  public @NotNull <T, O> OutboundPacket<ServerLevel, ServerPlayer, ItemStack, Object> createEntityMetaPacket(
+    @NotNull EntityMetadataFactory<T, O> metadata,
+    @NotNull T value
+  ) {
+    return (player, npc) -> {
+      // create the root entity metadata and check for the availability in the current version
+      var versionAccessor = npc.platform().versionAccessor();
+      var entityMetadata = metadata.create(value, versionAccessor);
+      if (!entityMetadata.available()) {
+        return;
+      }
+
+      // register the root entity metadata
+      var entries = new ArrayList<SynchedEntityData.DataValue<?>>();
+      entries.add(createDataValue(entityMetadata.type(), entityMetadata.value(), entityMetadata.index()));
+
+      // add all dependant metas
+      for (var relatedMetadata : metadata.relatedMetadata()) {
+        var related = relatedMetadata.create(value, versionAccessor);
+        if (related.available()) {
+          entries.add(createDataValue(related.type(), related.value(), related.index()));
+        }
+      }
+
+      // create & send the packet
+      var packet = new ClientboundSetEntityDataPacket(npc.entityId(), entries);
+      player.connection.send(packet);
+    };
+  }
+
+  @Override
+  public void initialize(@NotNull Platform<ServerLevel, ServerPlayer, ItemStack, Object> platform) {
+    FabricActionControllerEvents.SERVER_PLAYER_ENTITY_INTERACT.register((entityId, player, actionType, hand) -> {
+      var npc = platform.npcTracker().npcById(entityId);
+      if (npc != null) {
+        return switch (actionType) {
+          case ATTACK -> {
+            platform.eventManager().post(DefaultAttackNpcEvent.attackNpc(npc, player));
+            yield true;
+          }
+          case INTERACT -> {
+            var convertedHand = HAND_CONVERTER.get(hand);
+            platform.eventManager().post(DefaultInteractNpcEvent.interactNpc(npc, player, convertedHand));
+            yield true;
+          }
+          default -> false;
+        };
+      }
+
+      return false;
+    });
+  }
+}
diff --git a/fabric/src/main/java/com/github/juliarn/npclib/fabric/util/FabricUtil.java b/fabric/src/main/java/com/github/juliarn/npclib/fabric/util/FabricUtil.java
new file mode 100644
index 0000000..4e69465
--- /dev/null
+++ b/fabric/src/main/java/com/github/juliarn/npclib/fabric/util/FabricUtil.java
@@ -0,0 +1,74 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.fabric.util;
+
+import com.github.juliarn.npclib.api.Npc;
+import com.github.juliarn.npclib.api.Position;
+import java.util.Objects;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.Mth;
+import net.minecraft.world.phys.Vec2;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+@ApiStatus.Internal
+public final class FabricUtil {
+
+  // @MonotonicNonNull
+  private static MinecraftServer theServer;
+
+  private FabricUtil() {
+    throw new UnsupportedOperationException();
+  }
+
+  public static @NotNull MinecraftServer getServer() {
+    Objects.requireNonNull(FabricUtil.theServer, "server not yet set");
+    return FabricUtil.theServer;
+  }
+
+  public static void setServer(@NotNull MinecraftServer theServer) {
+    if (FabricUtil.theServer != null) {
+      throw new IllegalStateException("server already set");
+    }
+
+    FabricUtil.theServer = theServer;
+  }
+
+  public static double distance(@NotNull Npc<?, ?, ?, ?> npc, @NotNull Vec3 other) {
+    Position pos = npc.position();
+    return Mth.square(other.x() - pos.x()) + Mth.square(other.y() - pos.y()) + Mth.square(other.z() - pos.z());
+  }
+
+  public static @NotNull Position positionFromPosAndRot(
+    @NotNull ServerLevel level,
+    @NotNull Vec3 pos,
+    @NotNull Vec2 rot
+  ) {
+    var worldId = level.dimension().location().toString();
+    return Position.position(pos.x(), pos.y(), pos.z(), rot.x, rot.y, worldId);
+  }
+}
diff --git a/fabric/src/main/resources/fabric.mod.json b/fabric/src/main/resources/fabric.mod.json
new file mode 100644
index 0000000..47d9a49
--- /dev/null
+++ b/fabric/src/main/resources/fabric.mod.json
@@ -0,0 +1,31 @@
+{
+  "schemaVersion": 1,
+  "id": "npc_lib",
+  "version": "${version}",
+  "license": "MIT",
+  "environment": "server",
+  "name": "NPC-Lib",
+  "description": "Simple & Extendable NPC library for Minecraft Java Edition Servers",
+  "authors": [
+    "derklaro"
+  ],
+  "contact": {
+    "sources": "https://github.com/juliarn/npc-lib",
+    "issues": "https://github.com/juliarn/npc-lib/issues"
+  },
+  "entrypoints": {
+    "main": [
+      "com.github.juliarn.npclib.fabric.FabricModInitializer"
+    ]
+  },
+  "mixins": [
+    "npc_lib.mixins.json"
+  ],
+  "accessWidener": "npc_lib.accesswidener",
+  "depends": {
+    "fabricloader": ">=0.16.9",
+    "minecraft": "~1.21.4",
+    "java": ">=21",
+    "fabric-networking-api-v1": "*"
+  }
+}
diff --git a/fabric/src/main/resources/npc_lib.accesswidener b/fabric/src/main/resources/npc_lib.accesswidener
new file mode 100644
index 0000000..55cf16b
--- /dev/null
+++ b/fabric/src/main/resources/npc_lib.accesswidener
@@ -0,0 +1,16 @@
+accessWidener	v2 named
+accessible    field     net/minecraft/network/protocol/game/ClientboundPlayerInfoUpdatePacket     entries     Ljava/util/List;
+mutable       field     net/minecraft/network/protocol/game/ClientboundPlayerInfoUpdatePacket     entries     Ljava/util/List;
+
+accessible    field     net/minecraft/network/protocol/game/ClientboundRotateHeadPacket           entityId    I
+mutable       field     net/minecraft/network/protocol/game/ClientboundRotateHeadPacket           entityId    I
+
+accessible    field     net/minecraft/network/protocol/game/ClientboundAnimatePacket              id          I
+mutable       field     net/minecraft/network/protocol/game/ClientboundAnimatePacket              id          I
+
+accessible    class     net/minecraft/network/protocol/game/ServerboundInteractPacket$Action
+accessible    class     net/minecraft/network/protocol/game/ServerboundInteractPacket$ActionType
+accessible    class     net/minecraft/network/protocol/game/ServerboundInteractPacket$InteractionAction
+accessible    field     net/minecraft/network/protocol/game/ServerboundInteractPacket                         entityId    I
+accessible    field     net/minecraft/network/protocol/game/ServerboundInteractPacket$InteractionAction       hand        Lnet/minecraft/world/InteractionHand;
+accessible    field     net/minecraft/network/protocol/game/ServerboundInteractPacket                         action      Lnet/minecraft/network/protocol/game/ServerboundInteractPacket$Action;
diff --git a/fabric/src/main/resources/npc_lib.mixins.json b/fabric/src/main/resources/npc_lib.mixins.json
new file mode 100644
index 0000000..3533e91
--- /dev/null
+++ b/fabric/src/main/resources/npc_lib.mixins.json
@@ -0,0 +1,14 @@
+{
+  "required": true,
+  "package": "com.github.juliarn.npclib.fabric.mixins",
+  "compatibilityLevel": "JAVA_21",
+  "server": [
+    "MinecraftServerMixin",
+    "PlayerListMixin",
+    "ServerGamePacketListenerImplMixin",
+    "ServerPlayerMixin"
+  ],
+  "injectors": {
+    "defaultRequire": 1
+  }
+}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index a2de4ba..314049b 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -16,6 +16,12 @@ sponge = "10.0.0"
 minestom = "32735340d7"
 paper = "1.21.4-R0.1-SNAPSHOT"
 
+# fabric
+minecraft = "1.21.4"
+fabricLoom = "1.9.2"
+fabricLoader = "0.16.10"
+fabricApi = "0.115.0+1.21.4"
+
 # platform extensions
 paperLib = "1.0.8"
 packetEvents = "2.7.0"
@@ -35,6 +41,12 @@ paper = { group = "io.papermc.paper", name = "paper-api", version.ref = "paper"
 sponge = { group = "org.spongepowered", name = "spongeapi", version.ref = "sponge" }
 minestom = { group = "net.minestom", name = "minestom-snapshots", version.ref = "minestom" }
 
+# fabric
+minecraft = { group = "com.mojang", name = "minecraft", version.ref = "minecraft" }
+fabricLoader = { group = "net.fabricmc", name = "fabric-loader", version.ref = "fabricLoader" }
+fabricApiBom = { module = "net.fabricmc.fabric-api:fabric-api-bom", version.ref = "fabricApi" }
+fabricApiNetworkingV1 = { module = "net.fabricmc.fabric-api:fabric-networking-api-v1" }
+
 # platform extensions
 paperLib = { group = "io.papermc", name = "paperlib", version.ref = "paperLib" }
 protocolLib = { group = "com.github.dmulloy2", name = "ProtocolLib", version.ref = "protocolLib" }
@@ -45,5 +57,6 @@ checkstyleTools = { group = "com.puppycrawl.tools", name = "checkstyle", version
 
 [plugins]
 
+fabricLoom = { id = "fabric-loom", version.ref = "fabricLoom" }
 spotless = { id = "com.diffplug.spotless", version.ref = "spotless" }
 nexusPublish = { id = "io.github.gradle-nexus.publish-plugin", version.ref = "nexusPublish" }
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 98da9ed..2871b76 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -25,8 +25,18 @@
 enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
 enableFeaturePreview("STABLE_CONFIGURATION_CACHE")
 
+pluginManagement {
+  repositories {
+    gradlePluginPortal()
+    maven {
+      name = "Fabric"
+      url = uri("https://maven.fabricmc.net/")
+    }
+  }
+}
+
 rootProject.name = "npc-lib"
-include(":api", ":common", ":bukkit", ":minestom", ":ext")
+include(":api", ":common", ":bukkit", ":minestom", ":fabric", ":ext")
 
 // external modules
 include(":ext:labymod")