Update README.md

Action: Check if release exists before releasing
Enable "any_archLinux" act runner for building jar
2024-01-30 11:14:01 +09:00 · 2024-01-22 18:29:29 +09:00 · 2024-01-20 20:01:54 +09:00 · 2024-01-17 14:51:42 +09:00 · 2024-01-17 14:48:56 +09:00 · 2024-01-17 14:48:37 +09:00
30 changed files with 803 additions and 562 deletions
--- a/.forgejo/workflows/build-jar.yaml
+++ b/.forgejo/workflows/build-jar.yaml
@ -5,8 +5,21 @@ on:
      - '*'

 jobs:
-  build-and-store-artifact:
-    runs-on: archLinux
+  check-release-exists:
+    runs-on: any_archLinux
+    outputs:
+      status: ${{ steps.release_exists_check.outputs.http_code }}
+    steps:
+      - name: Check if release already exists
+        id: release_exists_check
+        run: |
+          curl -X GET "https://git.seodisparate.com/api/v1/repos/stephenseo/TurnBasedMinecraftMod/releases/tags/${GITHUB_REF_NAME}" \
+          -H 'accept: application/json' -o release_check_resp.json 2>/dev/null \
+          -w '%{http_code}\n' | sed 's/^\([0-9]\+\)/http_code=\1/' >> "$GITHUB_OUTPUT"
+  build-and-create-release:
+    needs: check-release-exists
+    if: ${{ needs.check-release-exists.outputs.status == '404' }}
+    runs-on: any_archLinux
    steps:
      - run: git clone --depth=1 --no-single-branch https://git.seodisparate.com/stephenseo/TurnBasedMinecraftMod.git TurnBasedMinecraftMod
      - run: cd TurnBasedMinecraftMod && git checkout ${GITHUB_REF_NAME}
@ -24,7 +37,7 @@ jobs:
          \"name\": \"TurnBasedMinecraftMod version ${GITHUB_REF_NAME}\",
          \"body\": \"See the [Changelog](https://git.seodisparate.com/stephenseo/TurnBasedMinecraftMod/src/branch/neoforge/Changelog.md)

-              (Using OpenJDK Java.)
+              $(java --version | sed -n '1p;2,$s/^/    /p')
              $(javac --version)
              $(find TurnBasedMinecraftMod/build/libs -regex '.*all.jar$' -exec sha256sum '{}' ';')\",
          \"tag_name\": \"${GITHUB_REF_NAME}\"
--- a/.gitignore
+++ b/.gitignore
@ -22,3 +22,4 @@ eclipse
 run

 logs/
+runs/
--- a/Changelog.md
+++ b/Changelog.md
@ -1,5 +1,37 @@
 # Upcoming changes

+# Version NeoForge-1.25.2
+
+Fix invalid use of throwable potions. (Previously, the Player would "drink"
+splash/lingering potions when used.) Now, if a splash/lingering potion is
+"Use"d in battle, it will be thrown.
+
+Add experimental support for "right-click" of arbitrary items on hotbar when
+"Use" is used in battle.
+
+# Version Forge-1.25.2
+
+Fix invalid use of throwable potions. (Previously, the Player would "drink"
+splash/lingering potions when used.) Now, if a splash/lingering potion is
+"Use"d in battle, it will be thrown.
+
+Add experimental support for "right-click" of arbitrary items on hotbar when
+"Use" is used in battle.
+
+# Version Forge-1.25.1
+
+Add icon for mod in Mod list description.
+
+Update for Forge 49.0.19.
+Works on Forge Minecraft 1.20.4.
+
+# Version NeoForge-1.25.1
+
+Add icon for mod in Mod list description.
+
+Update for NeoForge 20.4.108-beta.  
+Works on NeoForge Minecraft 1.20.4.
+
 # Version NeoForge-1.25.0

 Add new dependency `j-ogg-vorbis`.
--- a/FAQ.md
+++ b/FAQ.md
@ -0,0 +1,77 @@
+## How do I use this mod to have turn-based-battle with any mob (including mobs from other mods)?
+
+To have turn-based-battle with a mob, it must have a config entry in the server
+config. This can either be done manually or be [done in-game via a
+command](https://www.youtube.com/watch?v=MK648OVHddE).
+
+## Is it possible to have a mob's config applied to any mob with a specific name?
+
+Yes, [this video explains this feature](https://www.youtube.com/watch?v=9lBETQFMd3A).
+
+## Can the mod play music while a battle is happening?
+
+Yes, you have to put the music (`.wav`, `.ogg`, or `.mp3`) in
+`.minecraft/config/TurnBasedMinecraft/Music/battle` and
+`.minecraft/config/TurnBasedMinecraft/Music/silly` . Note that `.wav`, `.ogg`,
+and `.mp3` music files are supported, but `.mid` files are disabled due to lack
+of volume control with the default Java library api. The config file can be
+edited to change what categories of entities trigger what type of music, but
+generally "passive" mobs trigger the "silly" music and everything else triggers
+"battle" music. Note that the default server config has turn-based-battle
+disabled for "passive" mobs.
+
+**Note that while .ogg Vorbis files are supported, .ogg Opus files are NOT
+supported.**
+
+One can use FFmpeg to convert music files into .ogg Vorbis:
+
+    ffmpeg -i <music_file_to_convert> -map a:0 -c:a libvorbis output.ogg
+
+## Why can't the mod play my mp3 files?
+
+The third-party-library used to load mp3 files seems to have issues with
+loading any mp3 file that isn't "barebones". Try removing the metadata of the
+mp3 file. I've found that using mp3s without album art embedded in it seems to
+work.
+
+**It is recommended to use .ogg Vorbis files instead of .mp3 files.**
+
+## Why do passive mobs don't start turn-based battle?
+
+By default, the `passive` category is set to "ignore turn-based-battle" in the
+server config. Use `/tbm-server-edit` to change this. (Click on
+`ignore_battle_types` which should be dark-green. A list of "categories" will
+appear at the bottom of the text. Click on `passive` to remove the "passive"
+category.)
+![Screenshot one of two showing how to unset passive category from ignore battle types list](https://seodisparate.com/static/uploads/TBMM_ignore_battle_types_screenshot0.png)
+![Screenshot two of two showing how to unset passive category from ignore battle types list](https://seodisparate.com/static/uploads/TBMM_ignore_battle_types_screenshot1.png)
+
+Alternatively, edit the [server config](https://github.com/Stephen-Seo/TurnBasedMinecraftMod/blob/ad78063a16c768f660dd086cba857a3be43a84b2/src/main/resources/assets/com_burnedkirby_turnbasedminecraft/TBM_Config.toml#L46)
+and remove "passive" from the ignore\_battle\_types list.
+
+## Why is the mod's config file missing?
+
+The mod needs to be run once to generate the default config file and
+directories for battle music. After running it once, you can now close
+Minecraft and edit the config found at
+`.minecraft/config/TurnBasedMinecraft/TBM_Config.toml` Note that some options
+only apply to the server and some only to the client, as specified in the
+config. This means that server config must be changed on the server side for it
+to take effect (local singleplayer will use all of the local config, but
+multiplayer setups will require the server config to be changed on the server
+side). [You can edit the server-side config in game via the "/tbm-server-edit"
+command](https://youtu.be/9xkbHNWkcIY).
+
+## I updated the mod, but now my config changes are back to default, what happened?
+
+Sometimes, I add new mob entries to the config, and increment the version
+number of the config. When the server/client starts, it checks the default
+config's version number with the existing config's version number. If the
+existing config is determined to be outdated, then it is renamed to a different
+name (which usually includes the date/time of when it was renamed), and the new
+default config is placed in its place. There is a config option to prevent this
+from happening, but it is strongly recommended to not disable this since this
+will cause updates to the config to never be placed in the mod's config
+directory. If you have changes you want to keep, but the mod renamed the
+original config, you will have to edit the `TBM_Config.toml` to have the
+changes you want from the renamed older config file.
--- a/2
+++ b/2
@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2018-2023 Stephen Seo
+Copyright (c) 2018-2024 Stephen Seo

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/README.md
+++ b/README.md
@ -8,11 +8,12 @@ Precompiled jars are available here:
 https://seodisparate.com/static/tbm_releases/  
 https://burnedkirby.com/tbmm_downloads/  
 https://www.curseforge.com/minecraft/mc-mods/turnbasedminecraft/files  
-https://modrinth.com/mod/turnbasedmc
+https://modrinth.com/mod/turnbasedmc  
+https://git.seodisparate.com/stephenseo/TurnBasedMinecraftMod/releases

 # Forge or NeoForge

-The `master` branch tracks the version of the mod for Minecraft Forge.
+The `forge` branch tracks the version of the mod for Minecraft Forge.

 The `neoforge` branch tracks the version of the mod for Minecraft NeoForge.

@ -53,10 +54,11 @@ in battle)
  affected by volume options (master and music sliders))~~ Midi file playback
  has been disabled for now due to lack of volume control issues. MP3 file
  playback sometimes fails, but seems to work better when the file is as
-  "barebones" as possible (no album art metadata in the file). It is recommended
-  to use `.ogg` files for music. Note that ogg Vorbis is supported, and NOT ogg
-  Opus. One can convert to ogg Vorbis with ffmpeg like this: `ffmpeg -i
-  <my_music_file_to_convert> -map a:0 -c:a libvorbis output.ogg`.
+  "barebones" as possible (no album art metadata in the file).
+  - It is recommended to use `.ogg` files for music.
+  - Note that ogg Vorbis is supported, and NOT ogg Opus.
+  - One can convert to ogg Vorbis with ffmpeg like this: `ffmpeg -i
+    <my_music_file_to_convert> -map a:0 -c:a libvorbis output.ogg`.
 - Config allows limiting number of combatants in turn-based battle.
 - Config can be modified (server-side) to add entries of mobs from other mods.
 (by default an unknown mob cannot enter turn-based battle, so the config must be
@ -70,7 +72,7 @@ configured for them.)

 Simply invoke `./gradlew build` in the mod directory and after some time the
 finished jar will be saved at
-`build/libs/TurnBasedMinecraft-NeoForge-1.25.0-all.jar`
+`build/libs/TurnBasedMinecraft-NeoForge-1.25.2-all.jar`

 # Reproducibility

@ -86,6 +88,10 @@ Tor-Einar Jarnbjo.
 This mod also uses [JavaMP3](https://github.com/kevinstadler/JavaMP3)
 which is licensed under the [MIT License](https://github.com/kevinstadler/JavaMP3/blob/master/LICENSE).

+# Frequently Asked Questions
+
+[See the FAQ page.](https://github.com/Stephen-Seo/TurnBasedMinecraftMod/blob/master/FAQ.md)
+
 # Related Videos

 [See related videos here](https://burnedkirby.com/posts/tbmm/)
--- a/Reproducibility.md
+++ b/Reproducibility.md
@ -4,6 +4,58 @@ Starting with version 1.24.0 of this mod, this file will list what version of
 Java was used to compile the jars. In theory, using the same version of Java
 should result in an identical jar due to reproducible builds.

+## NeoForge 1.25.2
+
+    $ java --version
+    openjdk 17.0.10 2024-01-16
+    OpenJDK Runtime Environment (build 17.0.10+7)
+    OpenJDK 64-Bit Server VM (build 17.0.10+7, mixed mode)
+
+    $ javac --version
+    javac 17.0.10
+
+    $ sha256sum build/libs/TurnBasedMinecraft-NeoForge-1.25.2-all.jar
+    c59533059eb322a616f38ab40ccbc7d4d6c1667a651328a4c6eb187fe16d7a6f  build/libs/TurnBasedMinecraft-NeoForge-1.25.2-all.jar
+
+## Forge 1.25.2
+
+    $ java --version
+    openjdk 17.0.10 2024-01-16
+    OpenJDK Runtime Environment (build 17.0.10+7)
+    OpenJDK 64-Bit Server VM (build 17.0.10+7, mixed mode)
+
+    $ javac --version
+    javac 17.0.10
+
+    $ sha256sum build/libs/TurnBasedMinecraft-Forge-1.25.2-all.jar
+    00bc7958431e161b0a512ce32b41c1a97516b00e109195294ee18d4abf58dc26  build/libs/TurnBasedMinecraft-Forge-1.25.2-all.jar
+
+## Forge 1.25.1
+
+    $ java --version
+    openjdk 17.0.9 2023-10-17
+    OpenJDK Runtime Environment (build 17.0.9+8)
+    OpenJDK 64-Bit Server VM (build 17.0.9+8, mixed mode)
+
+    $ javac --version
+    javac 17.0.9
+
+    $ sha256sum build/libs/TurnBasedMinecraft-Forge-1.25.1-all.jar
+    33711947eed8b24fa7fd65d36ecdb6ed78e144af8d7fff6e1bfa304cfe4a1d3d  build/libs/TurnBasedMinecraft-Forge-1.25.1-all.jar
+
+## NeoForge 1.25.1
+
+    $ java --version
+    openjdk 17.0.9 2023-10-17
+    OpenJDK Runtime Environment (build 17.0.9+8)
+    OpenJDK 64-Bit Server VM (build 17.0.9+8, mixed mode)
+
+    $ javac --version
+    javac 17.0.9
+
+    $ sha256sum build/libs/TurnBasedMinecraft-NeoForge-1.25.1-all.jar
+    b0ec086c356c4d3662dcea4bdd9aeb2b0786e4ef40e061599e81b529746e01ea  build/libs/TurnBasedMinecraft-NeoForge-1.25.1-all.jar
+
 ## NeoForge 1.25.0

    $ java --version
--- a/build.gradle
+++ b/build.gradle
@ -2,11 +2,11 @@ plugins {
    id 'eclipse'
    id 'idea'
    id 'maven-publish'
-    id 'net.neoforged.gradle.userdev' version '7.0.57'
+    id 'net.neoforged.gradle.userdev' version '7.0.80'
 }

-version = "1.25.0"
-group = "com.burnedkirby.TurnBasedMinecraft"
+version = mod_version
+group = mod_group_id
 archivesBaseName = "TurnBasedMinecraft-NeoForge"

 java.toolchain.languageVersion = JavaLanguageVersion.of(17)
@ -87,24 +87,26 @@ dependencies {
        jarJar.pin(it, '1.0.3')
    }

-    jarJar(group: 'com.github.stephengold', name: 'j-ogg-vorbis', version: '[1.0.4,2.0.0)')
+    jarJar(group: 'com.github.stephengold', name: 'j-ogg-vorbis', version: '[1.0.4, 2.0.0)') {
+        jarJar.pin(it, '1.0.4')
+    }
 }

 // This block of code expands all declared replace properties in the specified resource targets.
 // A missing property will result in an error. Properties are expanded using ${} Groovy notation.
 // When "copyIdeResources" is enabled, this will also run before the game launches in IDE environments.
 // See https://docs.gradle.org/current/dsl/org.gradle.language.jvm.tasks.ProcessResources.html
-tasks.named('processResources', ProcessResources).configure {
+tasks.withType(ProcessResources).configureEach {
    var replaceProperties = [
-            minecraft_version: minecraft_version, minecraft_version_range: minecraft_version_range,
+            minecraft_version   : minecraft_version, minecraft_version_range: minecraft_version_range,
            neo_version         : neo_version, neo_version_range: neo_version_range,
            loader_version_range: loader_version_range,
-            mod_id: mod_id, mod_name: mod_name, mod_license: mod_license, mod_version: mod_version,
-            mod_authors: mod_authors, mod_description: mod_description,
+            mod_id              : mod_id, mod_name: mod_name, mod_license: mod_license, mod_version: mod_version,
+            mod_authors         : mod_authors, mod_description: mod_description,
    ]
    inputs.properties replaceProperties

-    filesMatching(['META-INF/mods.toml', 'pack.mcmeta']) {
+    filesMatching(['META-INF/mods.toml']) {
        expand replaceProperties + [project: project]
    }
 }
@ -122,7 +124,6 @@ jar {
            "Implementation-Vendor" :"TurnBasedMinecraftMod_BK",
            // Do not place timestamp for the sake of reproducible builds
 //            "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
-//            "ContainedDeps": "javamp3-1.0.3.jar"
        ])
    }
 }
@ -136,25 +137,3 @@ tasks.withType(AbstractArchiveTask).configureEach {
 tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
 }
-
-// Example configuration to allow publishing using the maven-publish task
-// we define a custom artifact that is sourced from the reobfJar output task
-// and then declare that to be published
-// Note you'll need to add a repository here
-//def reobfFile = file("$buildDir/reobfJar/output.jar")
-//def reobfArtifact = artifacts.add('default', reobfFile) {
-//    type 'jar'
-//    builtBy 'reobfJar'
-//}
-//publishing {
-//    publications {
-//        mavenJava(MavenPublication) {
-//            artifact reobfArtifact
-//        }
-//    }
-//    repositories {
-//        maven {
-//            url "file:///${project.projectDir}/mcmodsrepo"
-//        }
-//    }
-//}
--- a/gradle.properties
+++ b/gradle.properties
@ -1,20 +1,25 @@
 org.gradle.jvmargs=-Xmx4096m
 org.gradle.daemon=false
+org.gradle.debug=false

-## Environment Properties
-
-# The Minecraft version must agree with the Forge version to get a valid artifact
-minecraft_version=1.20.2
+#read more on this at https://github.com/neoforged/NeoGradle/blob/NG_7.0/README.md#apply-parchment-mappings
+# you can also find the latest versions at: https://parchmentmc.org/docs/getting-started
+neogradle.subsystems.parchment.minecraftVersion=1.20.3
+neogradle.subsystems.parchment.mappingsVersion=2023.12.31
+# Environment Properties
+# You can find the latest versions here: https://projects.neoforged.net/neoforged/neoforge
+# The Minecraft version must agree with the Neo version to get a valid artifact
+minecraft_version=1.20.4
 # The Minecraft version range can use any release version of Minecraft as bounds.
 # Snapshots, pre-releases, and release candidates are not guaranteed to sort properly
 # as they do not follow standard versioning conventions.
-minecraft_version_range=[1.20.2,1.21)
+minecraft_version_range=[1.20.4,1.21)
 # The Neo version must agree with the Minecraft version to get a valid artifact
-neo_version=20.2.88
-# The Neo version range can use any version of Neo as bounds or match the loader version range
-neo_version_range=[20.2,)
-# The loader version range can only use the major version of Neo/FML as bounds
-loader_version_range=[1,)
+neo_version=20.4.109-beta
+# The Neo version range can use any version of Neo as bounds
+neo_version_range=[20.4,)
+# The loader version range can only use the major version of FML as bounds
+loader_version_range=[2,)

 ## Mod Properties

@ -26,14 +31,12 @@ mod_name=TurnBasedMinecraftMod
 # The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default.
 mod_license=MIT
 # The mod version. See https://semver.org/
-mod_version=1.25.0
+mod_version=1.25.2
 # The group ID for the mod. It is only important when publishing as an artifact to a Maven repository.
 # This should match the base package used for the mod sources.
 # See https://maven.apache.org/guides/mini/guide-naming-conventions.html
-#mod_group_id=com.example.examplemod
+mod_group_id=com.burnedkirby.TurnBasedMinecraft
 # The authors of the mod. This is a simple text string that is used for display purposes in the mod list.
 mod_authors=BurnedKirby a.k.a. Stephen Seo
 # The description of the mod. This is a simple multiline text string that is used for display purposes in the mod list.
 mod_description=Implements turn-based-battle in Minecraft.
-# Pack version - this changes each minecraft release, in general.
-pack_format_number=18
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/client/BattleGui.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/client/BattleGui.java
@ -5,13 +5,13 @@ import com.burnedkirby.TurnBasedMinecraft.common.Combatant;
 import com.burnedkirby.TurnBasedMinecraft.common.Config;
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
 import com.burnedkirby.TurnBasedMinecraft.common.networking.PacketBattleDecision;
-import com.mojang.blaze3d.vertex.PoseStack;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.components.AbstractButton;
 import net.minecraft.client.gui.components.Button;
 import net.minecraft.client.gui.screens.Screen;
 import net.minecraft.network.chat.Component;
+import net.neoforged.neoforge.network.PacketDistributor;

 import java.util.ConcurrentModificationException;
 import java.util.HashMap;
@ -150,11 +150,11 @@ public class BattleGui extends Screen {
 						.getSideAEntrySet()) {
 					if (e.getValue().entity != null) {
 						addRenderableWidget(new EntitySelectionButton(width / 4 - 60, y, 120, 20, e.getValue().entity.getDisplayName(), e.getKey(), true, (button) -> {
-							buttonActionEvent(button, ButtonAction.ATTACK_TARGET);
+							entityButtonActionEvent(button, ButtonAction.ATTACK_TARGET);
 						}));
 					} else {
 						addRenderableWidget(new EntitySelectionButton(width / 4 - 60, y, 120, 20, "Unknown", e.getKey(), true, (button) -> {
-							buttonActionEvent(button, ButtonAction.ATTACK_TARGET);
+							entityButtonActionEvent(button, ButtonAction.ATTACK_TARGET);
 						}));
 					}
 					y += 20;
@ -168,11 +168,11 @@ public class BattleGui extends Screen {
 						.getSideBEntrySet()) {
 					if (e.getValue().entity != null) {
 						addRenderableWidget(new EntitySelectionButton(width * 3 / 4 - 60, y, 120, 20, e.getValue().entity.getDisplayName(), e.getKey(), false, (button) -> {
-							buttonActionEvent(button, ButtonAction.ATTACK_TARGET);
+							entityButtonActionEvent(button, ButtonAction.ATTACK_TARGET);
 						}));
 					} else {
 						addRenderableWidget(new EntitySelectionButton(width * 3 / 4 - 60, y, 120, 20, "Unknown", e.getKey(), false, (button) -> {
-							buttonActionEvent(button, ButtonAction.ATTACK_TARGET);
+							entityButtonActionEvent(button, ButtonAction.ATTACK_TARGET);
 						}));
 					}
 					y += 20;
@ -202,8 +202,8 @@ public class BattleGui extends Screen {
 		case SWITCH_ITEM:
 			info = "To which item will you switch to?";
 			for (int i = 0; i < 9; ++i) {
-				addRenderableWidget(new ItemSelectionButton(width / 2 - 88 + i * 20, height - 19, 16, 16, "", i, (button) -> {
-					buttonActionEvent(button, ButtonAction.DO_ITEM_SWITCH);
+				addRenderableWidget(new ItemSelectionButton(width / 2 - 88 + i * 20, height - 19, 16, 16, i, (button) -> {
+					itemButtonActionEvent(button, ButtonAction.DO_ITEM_SWITCH);
 				}));
 			}
 			addRenderableWidget(Button.builder(Component.literal("Cancel"), (button) -> {
@ -213,8 +213,8 @@ public class BattleGui extends Screen {
 		case USE_ITEM:
 			info = "Which item will you use?";
 			for (int i = 0; i < 9; ++i) {
-				addRenderableWidget(new ItemSelectionButton(width / 2 - 88 + i * 20, height - 19, 16, 16, "", i, (button) -> {
-					buttonActionEvent(button, ButtonAction.DO_USE_ITEM);
+				addRenderableWidget(new ItemSelectionButton(width / 2 - 88 + i * 20, height - 19, 16, 16, i, (button) -> {
+					itemButtonActionEvent(button, ButtonAction.DO_USE_ITEM);
 				}));
 			}
 			addRenderableWidget(Button.builder(Component.literal("Cancel"), (button) -> {
@ -275,27 +275,21 @@ public class BattleGui extends Screen {
 			setState(MenuState.ATTACK_TARGET);
 			break;
 		case DEFEND:
-			TurnBasedMinecraftMod.getHandler().sendToServer(new PacketBattleDecision(
-					TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.DEFEND, 0));
+			PacketDistributor.SERVER.noArg().send(new PacketBattleDecision(
+				TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.DEFEND, 0));
 			setState(MenuState.WAITING);
 			break;
 		case ITEM:
 			setState(MenuState.ITEM_ACTION);
 			break;
 		case FLEE:
-			TurnBasedMinecraftMod.getHandler().sendToServer(new PacketBattleDecision(
-					TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.FLEE, 0));
+			PacketDistributor.SERVER.noArg().send(new PacketBattleDecision(
+				TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.FLEE, 0));
 			setState(MenuState.WAITING);
 			break;
 		case ATTACK_TARGET:
-			if (button instanceof EntitySelectionButton) {
-				TurnBasedMinecraftMod.getHandler()
-						.sendToServer(new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
-								Battle.Decision.ATTACK, ((EntitySelectionButton) button).getID()));
-				setState(MenuState.WAITING);
-			} else {
-				setState(MenuState.MAIN_MENU);
-			}
+			// Invalid, but set menu to main menu anyways.
+			setState(MenuState.MAIN_MENU);
 			break;
 		case SWITCH_HELD_ITEM:
 			setState(MenuState.SWITCH_ITEM);
@ -307,31 +301,50 @@ public class BattleGui extends Screen {
 			setState(MenuState.MAIN_MENU);
 			break;
 		case DO_ITEM_SWITCH:
-			if (button instanceof ItemSelectionButton) {
-				TurnBasedMinecraftMod.getHandler()
-						.sendToServer(new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
-								Battle.Decision.SWITCH_ITEM, ((ItemSelectionButton) button).getID()));
-				if (((ItemSelectionButton) button).getID() >= 0 && ((ItemSelectionButton) button).getID() < 9) {
-					Minecraft.getInstance().player.getInventory().selected = ((ItemSelectionButton) button).getID();
-				}
-				setState(MenuState.WAITING);
-			} else {
-				setState(MenuState.MAIN_MENU);
-			}
+			// Invalid, but set menu to main menu anyways.
+			setState(MenuState.MAIN_MENU);
 			break;
 		case DO_USE_ITEM:
-			if (button instanceof ItemSelectionButton) {
-				TurnBasedMinecraftMod.getHandler()
-						.sendToServer(new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
-								Battle.Decision.USE_ITEM, ((ItemSelectionButton) button).getID()));
-				setState(MenuState.WAITING);
-			} else {
-				setState(MenuState.MAIN_MENU);
-			}
+			// Invalid, but set menu to main menu anyways.
+			setState(MenuState.MAIN_MENU);
 			break;
 		}
 	}

+	protected void entityButtonActionEvent(EntitySelectionButton button, ButtonAction action) {
+		if (action.equals(ButtonAction.ATTACK_TARGET)) {
+			PacketDistributor.SERVER.noArg().send(
+				new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
+					Battle.Decision.ATTACK, ((EntitySelectionButton) button).getID()));
+			setState(MenuState.WAITING);
+		} else {
+			setState(MenuState.MAIN_MENU);
+		}
+	}
+
+	protected void itemButtonActionEvent(ItemSelectionButton button, ButtonAction action) {
+		switch (action) {
+			case DO_ITEM_SWITCH:
+				PacketDistributor.SERVER.noArg().send(
+					new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
+						Battle.Decision.SWITCH_ITEM, button.getID()));
+				if (button.getID() >= 0 && button.getID() < 9) {
+					Minecraft.getInstance().player.getInventory().selected = button.getID();
+				}
+				setState(MenuState.WAITING);
+				break;
+			case DO_USE_ITEM:
+				PacketDistributor.SERVER.noArg().send(
+					new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
+						Battle.Decision.USE_ITEM, button.getID()));
+				setState(MenuState.WAITING);
+				break;
+			default:
+				setState(MenuState.MAIN_MENU);
+				break;
+		}
+	}
+
 	@Override
 	public boolean isPauseScreen() {
 		return false;
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/client/ClientProxy.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/client/ClientProxy.java
@ -15,7 +15,7 @@ import net.minecraft.resources.ResourceKey;
 import net.minecraft.sounds.SoundSource;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.level.Level;
-import net.neoforged.neoforge.network.NetworkEvent;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;

 public class ClientProxy extends CommonProxy {
    private BattleGui battleGui = null;
@ -222,7 +222,7 @@ public class ClientProxy extends CommonProxy {
    }

    @Override
-    public <MSG> void handlePacket(MSG msg, NetworkEvent.Context ctx) {
+    public <MSG> void handlePacket(final MSG msg, final PlayPayloadContext ctx) {
        if (msg.getClass() == PacketBattleMessage.class) {
            PacketBattleMessage pkt = (PacketBattleMessage) msg;
            Entity fromEntity = getEntity(pkt.getEntityIDFrom(), pkt.getDimension());
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/client/EntitySelectionButton.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/client/EntitySelectionButton.java
@ -1,34 +1,49 @@
 package com.burnedkirby.TurnBasedMinecraft.client;

-import com.burnedkirby.TurnBasedMinecraft.common.CommonProxy;
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
-import com.mojang.blaze3d.vertex.PoseStack;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.client.gui.components.AbstractButton;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.components.Renderable;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.narration.NarratableEntry;
 import net.minecraft.client.gui.narration.NarratedElementType;
 import net.minecraft.client.gui.narration.NarrationElementOutput;
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.LivingEntity;

-public class EntitySelectionButton extends AbstractButton {
-    TBMButtonPress onPress;
+public class EntitySelectionButton implements Renderable, GuiEventListener, NarratableEntry {
+    private int x;
+    private int y;
+    private int width;
+    private int height;
+    private boolean focused;
+    private Button nestedButton;
+    TBMEntityButtonPress onPress;
    private int entityID;
    private boolean isSideA;

-    public EntitySelectionButton(int x, int y, int widthIn, int heightIn, String buttonText, int entityID, boolean isSideA, TBMButtonPress onPress) {
-        super(x, y, widthIn, heightIn, Component.literal(buttonText));
+    public EntitySelectionButton(int x, int y, int widthIn, int heightIn, String buttonText, int entityID, boolean isSideA, TBMEntityButtonPress onPress) {
+        this.x = x;
+        this.y = y;
+        this.width = widthIn;
+        this.height = heightIn;
        this.onPress = onPress;
        this.entityID = entityID;
        this.isSideA = isSideA;
+        this.nestedButton = Button.builder(Component.literal(buttonText), (unused) -> {}).pos(x, y).size(widthIn, heightIn).build();
    }

-    public EntitySelectionButton(int x, int y, int widthIn, int heightIn, Component buttonTextComponent, int entityID, boolean isSideA, TBMButtonPress onPress) {
-        super(x, y, widthIn, heightIn, buttonTextComponent);
+    public EntitySelectionButton(int x, int y, int widthIn, int heightIn, Component buttonTextComponent, int entityID, boolean isSideA, TBMEntityButtonPress onPress) {
+        this.x = x;
+        this.y = y;
+        this.width = widthIn;
+        this.height = heightIn;
        this.onPress = onPress;
        this.entityID = entityID;
        this.isSideA = isSideA;
+        this.nestedButton = Button.builder(buttonTextComponent, (unused) -> {}).pos(x, y).size(widthIn, heightIn).build();
    }

    public int getID() {
@ -41,63 +56,86 @@ public class EntitySelectionButton extends AbstractButton {

    @Override
    public void render(GuiGraphics guiGraphics, int mouseX, int mouseY, float partialTicks) {
-        super.render(guiGraphics, mouseX, mouseY, partialTicks);
+        this.nestedButton.render(guiGraphics, mouseX, mouseY, partialTicks);
        Entity e = Minecraft.getInstance().level.getEntity(entityID);
        if (e != null && e instanceof LivingEntity && ((LivingEntity) e).isAlive()) {
            int health = (int) (((LivingEntity) e).getHealth() + 0.5f);
-            int xpos = getX();
+            int xpos = this.x;
            int xoffset;
            if (isSideA) {
-                xpos += getWidth() + 4;
+                xpos += this.width + 4;
                xoffset = 4;
            } else {
                xpos -= 6;
                xoffset = -4;
            }
            if (health > 200) {
-                guiGraphics.fill(xpos, getY() + getHeight() * 4 / 5, xpos + 2, getY() + getHeight(), 0xFFFF0000);
-                guiGraphics.fill(xpos, getY() + getHeight() * 3 / 5, xpos + 2, getY() + getHeight() * 4 / 5, 0xFFFFFF00);
-                guiGraphics.fill(xpos, getY() + getHeight() * 2 / 5, xpos + 2, getY() + getHeight() * 3 / 5, 0xFF00FF00);
-                guiGraphics.fill(xpos, getY() + getHeight() / 5, xpos + 2, getY() + getHeight() * 2 / 5, 0xFF00FFFF);
-                guiGraphics.fill(xpos, getY(), xpos + 2, getY() + getHeight() / 5, 0xFF0000FF);
-                int healthHeight = ((health - 200) * getHeight() / 100);
-                guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFFFFFFFF);
+                guiGraphics.fill(xpos, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
+                guiGraphics.fill(xpos, this.y + this.height * 3 / 5, xpos + 2, this.y + this.height * 4 / 5, 0xFFFFFF00);
+                guiGraphics.fill(xpos, this.y + this.height * 2 / 5, xpos + 2, this.y + this.height * 3 / 5, 0xFF00FF00);
+                guiGraphics.fill(xpos, this.y + this.height / 5, xpos + 2, this.y + this.height * 2 / 5, 0xFF00FFFF);
+                guiGraphics.fill(xpos, this.y, xpos + 2, this.y + this.height / 5, 0xFF0000FF);
+                int healthHeight = ((health - 200) * this.height / 100);
+                guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFFFFFFFF);
            } else if (health > 100) {
-                guiGraphics.fill(xpos, getY() + getHeight() * 4 / 5, xpos + 2, getY() + getHeight(), 0xFFFF0000);
-                guiGraphics.fill(xpos, getY() + getHeight() * 3 / 5, xpos + 2, getY() + getHeight() * 4 / 5, 0xFFFFFF00);
-                guiGraphics.fill(xpos, getY() + getHeight() * 2 / 5, xpos + 2, getY() + getHeight() * 3 / 5, 0xFF00FF00);
-                guiGraphics.fill(xpos, getY() + getHeight() / 5, xpos + 2, getY() + getHeight() * 2 / 5, 0xFF00FFFF);
-                int healthHeight = ((health - 100) * getHeight() / 100);
-                guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFF0000FF);
+                guiGraphics.fill(xpos, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
+                guiGraphics.fill(xpos, this.y + this.height * 3 / 5, xpos + 2, this.y + this.height * 4 / 5, 0xFFFFFF00);
+                guiGraphics.fill(xpos, this.y + this.height * 2 / 5, xpos + 2, this.y + this.height * 3 / 5, 0xFF00FF00);
+                guiGraphics.fill(xpos, this.y + this.height / 5, xpos + 2, this.y + this.height * 2 / 5, 0xFF00FFFF);
+                int healthHeight = ((health - 100) * this.height / 100);
+                guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFF0000FF);
            } else if (health > 50) {
-                guiGraphics.fill(xpos, getY() + getHeight() * 4 / 5, xpos + 2, getY() + getHeight(), 0xFFFF0000);
-                guiGraphics.fill(xpos, getY() + getHeight() * 3 / 5, xpos + 2, getY() + getHeight() * 4 / 5, 0xFFFFFF00);
-                guiGraphics.fill(xpos, getY() + getHeight() * 2 / 5, xpos + 2, getY() + getHeight() * 3 / 5, 0xFF00FF00);
-                int healthHeight = ((health - 50) * getHeight() / 50);
-                guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFF00FFFF);
+                guiGraphics.fill(xpos, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
+                guiGraphics.fill(xpos, this.y + this.height * 3 / 5, xpos + 2, this.y + this.height * 4 / 5, 0xFFFFFF00);
+                guiGraphics.fill(xpos, this.y + this.height * 2 / 5, xpos + 2, this.y + this.height * 3 / 5, 0xFF00FF00);
+                int healthHeight = ((health - 50) * this.height / 50);
+                guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFF00FFFF);
            } else if (health > 20) {
-                guiGraphics.fill(xpos, getY() + getHeight() * 4 / 5, xpos + 2, getY() + getHeight(), 0xFFFF0000);
-                guiGraphics.fill(xpos, getY() + getHeight() * 3 / 5, xpos + 2, getY() + getHeight() * 4 / 5, 0xFFFFFF00);
-                int healthHeight = ((health - 20) * getHeight() / 30);
-                guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFF00FF00);
+                guiGraphics.fill(xpos, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
+                guiGraphics.fill(xpos, this.y + this.height * 3 / 5, xpos + 2, this.y + this.height * 4 / 5, 0xFFFFFF00);
+                int healthHeight = ((health - 20) * this.height / 30);
+                guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFF00FF00);
            } else if (health > 10) {
-                guiGraphics.fill(xpos, getY() + getHeight() * 4 / 5, xpos + 2, getY() + getHeight(), 0xFFFF0000);
-                int healthHeight = ((health - 10) * getHeight() / 10);
-                guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFFFFFF00);
+                guiGraphics.fill(xpos, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
+                int healthHeight = ((health - 10) * this.height / 10);
+                guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFFFFFF00);
            } else {
-                int healthHeight = (health * getHeight() / 10);
-                guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFFFF0000);
+                int healthHeight = (health * this.height / 10);
+                guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFFFF0000);
            }
        }
    }

-    @Override
-    protected void updateWidgetNarration(NarrationElementOutput p_259858_) {
-        p_259858_.add(NarratedElementType.HINT, TurnBasedMinecraftMod.proxy.getEntity(entityID, Minecraft.getInstance().level.dimension()).getName());
-    }
-
-    @Override
    public void onPress() {
        onPress.onPress(this);
    }
+
+    @Override
+    public void setFocused(boolean b) {
+        this.focused = b;
+    }
+
+    @Override
+    public boolean isFocused() {
+        return focused;
+    }
+
+    @Override
+    public NarrationPriority narrationPriority() {
+        return NarrationPriority.FOCUSED;
+    }
+
+    @Override
+    public void updateNarration(NarrationElementOutput narrationElementOutput) {
+        narrationElementOutput.add(NarratedElementType.HINT, TurnBasedMinecraftMod.proxy.getEntity(entityID, Minecraft.getInstance().level.dimension()).getName());
+    }
+
+    @Override
+    public boolean mouseClicked(double x, double y, int unknown) {
+        if (unknown == 0 && x >= this.x && y >= this.y && x <= (double)(this.x + this.width) && y <= (double)(this.y + this.height)) {
+            onPress();
+            return true;
+        }
+        return false;
+    }
 }
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/client/ItemSelectionButton.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/client/ItemSelectionButton.java
@ -1,19 +1,26 @@
 package com.burnedkirby.TurnBasedMinecraft.client;

-import com.mojang.blaze3d.vertex.PoseStack;
 import net.minecraft.client.gui.GuiGraphics;
-import net.minecraft.client.gui.components.AbstractButton;
+import net.minecraft.client.gui.components.Renderable;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.narration.NarratableEntry;
 import net.minecraft.client.gui.narration.NarratedElementType;
 import net.minecraft.client.gui.narration.NarrationElementOutput;
-import net.minecraft.network.chat.Component;

-public class ItemSelectionButton extends AbstractButton {
-
-    TBMButtonPress onPress;
+public class ItemSelectionButton implements Renderable, GuiEventListener, NarratableEntry {
+    private int x;
+    private int y;
+    private int width;
+    private int height;
+    TBMItemButtonPress onPress;
    private int itemStackID;
+    private boolean focused;

-    public ItemSelectionButton(int x, int y, int widthIn, int heightIn, String buttonText, int itemStackID, TBMButtonPress onPress) {
-        super(x, y, widthIn, heightIn, Component.literal(buttonText));
+    public ItemSelectionButton(int x, int y, int widthIn, int heightIn, int itemStackID, TBMItemButtonPress onPress) {
+        this.x = x;
+        this.y = y;
+        this.width = widthIn;
+        this.height = heightIn;
        this.onPress = onPress;
        this.itemStackID = itemStackID;
    }
@ -24,23 +31,44 @@ public class ItemSelectionButton extends AbstractButton {

    @Override
    public void render(GuiGraphics guiGraphics, int mouseX, int mouseY, float unk) {
-        if (visible) {
-            boolean hovered = mouseX >= getX() && mouseY >= getY() && mouseX < getX() + getWidth() && mouseY < getY() + getHeight();
-            if (hovered) {
-                guiGraphics.fill(getX(), getY(), getX() + getWidth(), getY() + getHeight(), 0x80FFFFFF);
-            } else {
-                guiGraphics.fill(getX(), getY(), getX() + getWidth(), getY() + getHeight(), 0x20707070);
-            }
+        boolean hovered = mouseX >= this.x && mouseY >= this.y && mouseX < this.x + this.width && mouseY < this.y + this.height;
+        if (hovered) {
+            guiGraphics.fill(this.x, this.y, this.x + this.width, this.y + this.height, 0x80FFFFFF);
+        } else {
+            guiGraphics.fill(this.x, this.y, this.x + this.width, this.y + this.height, 0x20707070);
        }
    }

-    @Override
-    protected void updateWidgetNarration(NarrationElementOutput p_259858_) {
-        p_259858_.add(NarratedElementType.HINT, "Item " + this.itemStackID);
-    }
-
-    @Override
    public void onPress() {
        onPress.onPress(this);
    }
-}
+
+    @Override
+    public void setFocused(boolean b) {
+        focused = b;
+    }
+
+    @Override
+    public boolean isFocused() {
+        return focused;
+    }
+
+    @Override
+    public NarrationPriority narrationPriority() {
+        return NarrationPriority.FOCUSED;
+    }
+
+    @Override
+    public void updateNarration(NarrationElementOutput narrationElementOutput) {
+        narrationElementOutput.add(NarratedElementType.HINT, "Item " + this.itemStackID);
+    }
+
+    @Override
+    public boolean mouseClicked(double x, double y, int unknown) {
+        if (unknown == 0 && x >= this.x && y >= this.y && x <= (double)(this.x + this.width) && y <= (double)(this.y + this.height)) {
+            onPress();
+            return true;
+        }
+        return false;
+    }
+}
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/client/TBMEntityButtonPress.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/client/TBMEntityButtonPress.java
@ -0,0 +1,5 @@
+package com.burnedkirby.TurnBasedMinecraft.client;
+
+public interface TBMEntityButtonPress {
+    void onPress(EntitySelectionButton button);
+}
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/client/TBMItemButtonPress.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/client/TBMItemButtonPress.java
@ -0,0 +1,5 @@
+package com.burnedkirby.TurnBasedMinecraft.client;
+
+public interface TBMItemButtonPress {
+    void onPress(ItemSelectionButton button);
+}
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/AttackEventHandler.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/AttackEventHandler.java
@ -82,7 +82,7 @@ public class AttackEventHandler
                    	if(!event.getEntity().hasCustomName())
                        {
                            TurnBasedMinecraftMod.logger.error("Cannot edit custom name from entity without custom name");
-                            TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer)editingInfo.editor), new PacketGeneralMessage("Cannot edit custom name from entity without custom name"));
+                            PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor).send(new PacketGeneralMessage("Cannot edit custom name from entity without custom name"));
                            return;
                        }
                        editingInfo.entityInfo = config.getCustomEntityInfo(event.getEntity().getCustomName().getString());
@ -91,9 +91,9 @@ public class AttackEventHandler
                            editingInfo.entityInfo = new EntityInfo();
                            editingInfo.entityInfo.customName = event.getEntity().getCustomName().getString();
                        }
-                        TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer)editingInfo.editor), new PacketGeneralMessage("Editing custom name \"" + event.getEntity().getCustomName().getString() + "\""));
+                        PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor).send(new PacketGeneralMessage("Editing custom name \"" + event.getEntity().getCustomName().getString() + "\""));
                        TurnBasedMinecraftMod.logger.info("Begin editing custom \"" + event.getEntity().getCustomName().getString() + "\"");
-                        TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer)editingInfo.editor), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                        PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                    }
                    else
                    {
@ -107,9 +107,9 @@ public class AttackEventHandler
                        {
                            editingInfo.entityInfo = editingInfo.entityInfo.clone();
                        }
-                        TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer)editingInfo.editor), new PacketGeneralMessage("Editing entity \"" + editingInfo.entityInfo.classType.getName() + "\""));
+                        PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor).send(new PacketGeneralMessage("Editing entity \"" + editingInfo.entityInfo.classType.getName() + "\""));
                        TurnBasedMinecraftMod.logger.info("Begin editing \"" + editingInfo.entityInfo.classType.getName() + "\"");
-                        TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer)editingInfo.editor), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                        PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                    }
                    return;
                }
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/Battle.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/Battle.java
@ -449,7 +449,7 @@ public class Battle {
        }
        PacketBattleInfo infoPacket = new PacketBattleInfo(getSideAIDs(), getSideBIDs(), timer, TurnBasedMinecraftMod.proxy.getConfig().getDecisionDurationNanos(), !TurnBasedMinecraftMod.proxy.getConfig().isBattleDecisionDurationForever());
        for (Combatant p : players.values()) {
-            TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) p.entity), infoPacket);
+            PacketDistributor.PLAYER.with((ServerPlayer)p.entity).send(infoPacket);
        }
    }

@ -464,7 +464,7 @@ public class Battle {
        PacketBattleMessage packet = new PacketBattleMessage(type, from, to, dimension, amount, custom);
        for (Combatant p : players.values()) {
            if (p.entity.isAlive()) {
-                TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) p.entity), packet);
+                PacketDistributor.PLAYER.with((ServerPlayer)p.entity).send(packet);
            }
        }
    }
@ -574,7 +574,7 @@ public class Battle {

    private void removeCombatantPostRemove(Combatant c) {
        if (c.entity instanceof Player) {
-            TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) c.entity), new PacketBattleMessage(PacketBattleMessage.MessageType.ENDED, 0, 0, dimension, 0));
+            PacketDistributor.PLAYER.with((ServerPlayer)c.entity).send(new PacketBattleMessage(PacketBattleMessage.MessageType.ENDED, 0, 0, dimension, 0));
        }
        battleManager.addRecentlyLeftBattle(c);
    }
@ -1102,7 +1102,7 @@ public class Battle {
                                    final Entity nextEntity = next.entity;
                                    final int nextItemToUse = next.itemToUse;
                                    ((Player) nextEntity).getInventory().setItem(nextItemToUse, targetItem.finishUsingItem(targetItemStack, nextEntity.level(), (LivingEntity) nextEntity));
-                                } else if (targetItem instanceof PotionItem) {
+                                } else if (targetItem instanceof PotionItem && !(targetItem instanceof ThrowablePotionItem)) {
                                    debugLog += " potion";
                                    sendMessageToAllPlayers(PacketBattleMessage.MessageType.USED_ITEM, next.entity.getId(), 0, PacketBattleMessage.UsedItemAction.USED_POTION.getValue(), targetItemStack.getDisplayName().getString());
                                    final Entity nextEntity = next.entity;
@ -1113,7 +1113,10 @@ public class Battle {
                                    sendMessageToAllPlayers(PacketBattleMessage.MessageType.USED_ITEM, next.entity.getId(), 0, PacketBattleMessage.UsedItemAction.USED_INVALID.getValue(), targetItemStack.getDisplayName().getString());
                                    final Entity nextEntity = next.entity;
                                    final int nextItemToUse = next.itemToUse;
-                                    ((Player)nextEntity).getInventory().setItem(nextItemToUse, targetItem.finishUsingItem(targetItemStack, nextEntity.level(), (LivingEntity) nextEntity));
+                                    final int prevItem = ((Player)nextEntity).getInventory().selected;
+                                    ((Player)nextEntity).getInventory().selected = nextItemToUse;
+                                    ((Player)nextEntity).getInventory().setItem(nextItemToUse, targetItem.use(nextEntity.level(), (Player)nextEntity, InteractionHand.MAIN_HAND).getObject());
+                                    ((Player)nextEntity).getInventory().selected = prevItem;
                                }
                            }
                            break;
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/BattleManager.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/BattleManager.java
@ -317,7 +317,7 @@ public class BattleManager
        c.time = System.nanoTime();
        Config config = TurnBasedMinecraftMod.proxy.getConfig();
        if(c.entity instanceof ServerPlayer) {
-            TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(()->(ServerPlayer) c.entity), new PacketGeneralMessage("You just left battle! " + config.getLeaveBattleCooldownSeconds() + " seconds until you can attack/be-attacked again!"));
+            PacketDistributor.PLAYER.with((ServerPlayer)c.entity).send(new PacketGeneralMessage("You just left battle! " + config.getLeaveBattleCooldownSeconds() + " seconds until you can attack/be-attacked again!"));
        }
        recentlyLeftBattle.put(c.entity.getId(), c);
        entityToBattleMap.remove(new EntityIDDimPair(c.entity));
@ -337,7 +337,7 @@ public class BattleManager
                iter.remove();
                if(entry.getValue().entity instanceof ServerPlayer)
                {
-                    TurnBasedMinecraftMod.getHandler().send(PacketDistributor.PLAYER.with(()->(ServerPlayer)entry.getValue().entity), new PacketGeneralMessage("Timer ended, you can now attack/be-attacked again."));
+                    PacketDistributor.PLAYER.with((ServerPlayer)entry.getValue().entity).send(new PacketGeneralMessage("Timer ended, you can now attack/be-attacked again."));
                }
            }
        }
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/CommonProxy.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/CommonProxy.java
@ -5,7 +5,7 @@ import net.minecraft.resources.ResourceKey;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.Level;
-import net.neoforged.neoforge.network.NetworkEvent;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;
 import net.neoforged.neoforge.server.ServerLifecycleHooks;
 import org.apache.logging.log4j.Logger;

@ -172,5 +172,5 @@ public class CommonProxy
        return ServerLifecycleHooks.getCurrentServer().getLevel(dim).getEntity(id);
    }

-    public <MSG> void handlePacket(MSG msg, NetworkEvent.Context ctx) {}
+    public <MSG> void handlePacket(final MSG msg, final PlayPayloadContext ctx) {}
 }
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/DimensionChangedHandler.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/DimensionChangedHandler.java
@ -14,9 +14,7 @@ public class DimensionChangedHandler {
        }
        if(TurnBasedMinecraftMod.proxy.getBattleManager().forceLeaveBattle(new EntityIDDimPair(event.getEntity()))
                && event.getEntity() instanceof ServerPlayer) {
-            TurnBasedMinecraftMod.getHandler().send(
-                    PacketDistributor.PLAYER.with(() -> (ServerPlayer)event.getEntity()),
-                    new PacketGeneralMessage("Left battle due to moving to a different dimension"));
+            PacketDistributor.PLAYER.with((ServerPlayer)event.getEntity()).send(new PacketGeneralMessage("Left battle due to moving to a different dimension"));
        }
    }
 }
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/TurnBasedMinecraftMod.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/TurnBasedMinecraftMod.java
@ -19,6 +19,7 @@ import net.minecraft.network.chat.HoverEvent;
 import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
+import net.neoforged.bus.api.IEventBus;
 import net.neoforged.bus.api.SubscribeEvent;
 import net.neoforged.fml.loading.FMLEnvironment;
 import net.neoforged.neoforge.common.NeoForge;
@ -29,10 +30,9 @@ import net.neoforged.fml.common.Mod;
 import net.neoforged.fml.event.lifecycle.FMLClientSetupEvent;
 import net.neoforged.fml.event.lifecycle.FMLCommonSetupEvent;
 import net.neoforged.fml.event.lifecycle.FMLDedicatedServerSetupEvent;
-import net.neoforged.fml.javafmlmod.FMLJavaModLoadingContext;
-import net.neoforged.neoforge.network.NetworkRegistry;
+import net.neoforged.neoforge.network.event.RegisterPayloadHandlerEvent;
+import net.neoforged.neoforge.network.registration.IPayloadRegistrar;
 import net.neoforged.neoforge.network.PacketDistributor;
-import net.neoforged.neoforge.network.simple.SimpleChannel;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;

@ -40,7 +40,7 @@ import org.apache.logging.log4j.Logger;
 public class TurnBasedMinecraftMod {
    public static final String MODID = "com_burnedkirby_turnbasedminecraft";
    public static final String NAME = "Turn Based Minecraft Mod";
-    public static final String VERSION = "1.25.0";
+    public static final String VERSION = "1.25.2";
    public static final String CONFIG_FILENAME = "TBM_Config.toml";
    public static final String DEFAULT_CONFIG_FILENAME = "TBM_Config_DEFAULT.toml";
    public static final String CONFIG_DIRECTORY = "config/TurnBasedMinecraft/";
@ -53,32 +53,46 @@ public class TurnBasedMinecraftMod {

    private static final String PROTOCOL_VERSION = Integer.toString(3);
    private static final ResourceLocation HANDLER_ID = new ResourceLocation(MODID, "main_channel");
-    private static final SimpleChannel HANDLER = NetworkRegistry.ChannelBuilder
-        .named(HANDLER_ID)
-        .clientAcceptedVersions(PROTOCOL_VERSION::equals)
-        .serverAcceptedVersions(PROTOCOL_VERSION::equals)
-        .networkProtocolVersion(() -> PROTOCOL_VERSION)
-        .simpleChannel();
    protected static Logger logger = LogManager.getLogger();

    public static ResourceLocation getNetResourceLocation() {
        return HANDLER_ID;
    }

-    public static SimpleChannel getHandler() {
-        return HANDLER;
-    }
-
    public static CommonProxy proxy;

-    public TurnBasedMinecraftMod() {
-        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::firstInit);
-        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::secondInitClient);
-        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::secondInitServer);
-
+    public TurnBasedMinecraftMod(IEventBus eventBus) {
+        eventBus.addListener(this::firstInit);
+        eventBus.addListener(this::secondInitClient);
+        eventBus.addListener(this::secondInitServer);
+        eventBus.addListener(this::registerNetwork);
        NeoForge.EVENT_BUS.register(this);
    }

+    private void registerNetwork(final RegisterPayloadHandlerEvent event) {
+        final IPayloadRegistrar registrar = event.registrar(MODID);
+
+        registrar.play(PacketBattleDecision.ID, PacketBattleDecision::new, handler -> handler
+            .server(PacketBattleDecision.PayloadHandler.getInstance()::handleData));
+
+        registrar.play(PacketBattleInfo.ID, PacketBattleInfo::new, handler -> handler
+            .client(PacketBattleInfo.PayloadHandler.getInstance()::handleData));
+
+        registrar.play(PacketBattleMessage.ID, PacketBattleMessage::new, handler -> handler
+            .client(PacketBattleMessage.PayloadHandler.getInstance()::handleData));
+
+        registrar.play(PacketBattleRequestInfo.ID, PacketBattleRequestInfo::new, handler -> handler
+            .server(PacketBattleRequestInfo.PayloadHandler.getInstance()::handleData));
+
+        registrar.play(PacketEditingMessage.ID, PacketEditingMessage::new, handler -> handler
+            .client(PacketEditingMessage.PayloadHandler.getInstance()::handleData));
+
+        registrar.play(PacketGeneralMessage.ID, PacketGeneralMessage::new, handler -> handler
+            .client(PacketGeneralMessage.PayloadHandler.getInstance()::handleData));
+
+        logger.debug("Register packets com_burnedkirby_turnbasedminecraft");
+    }
+
    private void firstInit(final FMLCommonSetupEvent event) {
        if (FMLEnvironment.dist.isClient()) {
            proxy = new ClientProxy();
@ -88,45 +102,6 @@ public class TurnBasedMinecraftMod {
        proxy.setLogger(logger);
        proxy.initialize();

-        // register packets
-        int packetHandlerID = 0;
-        HANDLER.registerMessage(
-            packetHandlerID++,
-            PacketBattleInfo.class,
-            new PacketBattleInfo.Encoder(),
-            new PacketBattleInfo.Decoder(),
-            new PacketBattleInfo.Consumer());
-        HANDLER.registerMessage(
-            packetHandlerID++,
-            PacketBattleRequestInfo.class,
-            new PacketBattleRequestInfo.Encoder(),
-            new PacketBattleRequestInfo.Decoder(),
-            new PacketBattleRequestInfo.Consumer());
-        HANDLER.registerMessage(
-            packetHandlerID++,
-            PacketBattleDecision.class,
-            new PacketBattleDecision.Encoder(),
-            new PacketBattleDecision.Decoder(),
-            new PacketBattleDecision.Consumer());
-        HANDLER.registerMessage(
-            packetHandlerID++,
-            PacketBattleMessage.class,
-            new PacketBattleMessage.Encoder(),
-            new PacketBattleMessage.Decoder(),
-            new PacketBattleMessage.Consumer());
-        HANDLER.registerMessage(
-            packetHandlerID++,
-            PacketGeneralMessage.class,
-            new PacketGeneralMessage.Encoder(),
-            new PacketGeneralMessage.Decoder(),
-            new PacketGeneralMessage.Consumer());
-        HANDLER.registerMessage(
-            packetHandlerID++,
-            PacketEditingMessage.class,
-            new PacketEditingMessage.Encoder(),
-            new PacketEditingMessage.Decoder(),
-            new PacketEditingMessage.Consumer());
-
        // register event handler(s)
        NeoForge.EVENT_BUS.register(new AttackEventHandler());
        NeoForge.EVENT_BUS.register(new PlayerJoinEventHandler());
@ -177,7 +152,7 @@ public class TurnBasedMinecraftMod {
                    proxy.getConfig().setBattleDisabledForAll(true);
                    for (ServerPlayer player : c.getSource().getServer().getPlayerList().getPlayers()) {
                        proxy.getConfig().addBattleIgnoringPlayer(player.getId());
-                        getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("OP disabled turn-based-combat for everyone"));
+                        PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("OP disabled turn-based-combat for everyone"));
                    }
                    return 1;
                }));
@ -198,7 +173,7 @@ public class TurnBasedMinecraftMod {
                    proxy.getConfig().setBattleDisabledForAll(false);
                    proxy.getConfig().clearBattleIgnoringPlayers();
                    for (ServerPlayer player : c.getSource().getServer().getPlayerList().getPlayers()) {
-                        getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("OP enabled turn-based-combat for everyone"));
+                        PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("OP enabled turn-based-combat for everyone"));
                    }
                    return 1;
                }));
@ -209,7 +184,7 @@ public class TurnBasedMinecraftMod {
                .then(Commands.argument("targets", EntityArgument.players()).executes(c -> {
                    for (ServerPlayer player : EntityArgument.getPlayers(c, "targets")) {
                        proxy.getConfig().addBattleIgnoringPlayer(player.getId());
-                        getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("OP enabled turn-based-combat for you"));
+                        PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("OP enabled turn-based-combat for you"));
                        c.getSource().sendSuccess(() -> Component.literal("Enabled turn-based-combat for " + player.getDisplayName().getString()), true);
                    }
                    return 1;
@ -221,7 +196,7 @@ public class TurnBasedMinecraftMod {
                .then(Commands.argument("targets", EntityArgument.players()).executes(c -> {
                    for (ServerPlayer player : EntityArgument.getPlayers(c, "targets")) {
                        proxy.getConfig().removeBattleIgnoringPlayer(player.getId());
-                        getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("OP disabled turn-based-combat for you"));
+                        PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("OP disabled turn-based-combat for you"));
                        c.getSource().sendSuccess(() -> Component.literal("Disabled turn-based-combat for " + player.getDisplayName().getString()), true);
                    }
                    return 1;
@ -234,12 +209,12 @@ public class TurnBasedMinecraftMod {
                    ServerPlayer player = c.getSource().getPlayerOrException();
                    EditingInfo editingInfo = proxy.getEditingInfo(player.getId());
                    if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                        getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                        PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                    } else if (editingInfo != null) {
-                        getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                        PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                    } else {
                        proxy.setEditingPlayer(player);
-                        getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                        PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                        logger.info("Begin editing TBM Entity for player \"" + player.getDisplayName().getString() + "\" (\"" + c.getSource().getDisplayName() + "\")");
                    }
                    return 1;
@ -250,14 +225,14 @@ public class TurnBasedMinecraftMod {
                        EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                        if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                            if (!proxy.getConfig().editEntityEntry(editingInfo.entityInfo)) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("An error occurred while attempting to save an entry to the config"));
+                                PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("An error occurred while attempting to save an entry to the config"));
                                proxy.removeEditingInfo(player.getId());
                            } else {
                                proxy.removeEditingInfo(player.getId());
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("Entity info saved in config and loaded."));
+                                PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("Entity info saved in config and loaded."));
                            }
                        } else if (editingInfo != null) {
-                            getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                            PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                        } else {
                            Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                            throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -270,7 +245,7 @@ public class TurnBasedMinecraftMod {
                        EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                        if (editingInfo != null) {
                            proxy.removeEditingInfo(player.getId());
-                            getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("Cancelled editing entry."));
+                            PacketDistributor.PLAYER.with(player).send(new PacketGeneralMessage("Cancelled editing entry."));
                        }
                        return 1;
                    }))
@ -282,11 +257,11 @@ public class TurnBasedMinecraftMod {
                            Message exceptionMessage = new LiteralMessage("Invalid action for tbm-edit");
                            throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
                        } else if (editingInfo != null) {
-                            getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                            PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                        } else {
                            proxy.setEditingPlayer(player);
                            proxy.getEditingInfo(player.getId()).isEditingCustomName = true;
-                            getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                            PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            logger.info("Begin editing custom TBM Entity for player \"" + player.getDisplayName().getString() + "\" (\"" + c.getSource().getDisplayName() + "\")");
                        }
                        return 1;
@ -296,9 +271,9 @@ public class TurnBasedMinecraftMod {
                        ServerPlayer player = c.getSource().getPlayerOrException();
                        EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                        if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                            getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                            PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                        } else if (editingInfo != null) {
-                            getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                            PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                        } else {
                            Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                            throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -310,9 +285,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_IGNORE_BATTLE));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_IGNORE_BATTLE));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -326,9 +301,9 @@ public class TurnBasedMinecraftMod {
                                boolean ignoreBattle = BoolArgumentType.getBool(c, "ignoreBattle");
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.ignoreBattle = ignoreBattle;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -341,9 +316,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_POWER));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_POWER));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -360,9 +335,9 @@ public class TurnBasedMinecraftMod {
                                }
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.attackPower = attackPower;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -375,9 +350,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_PROBABILITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_PROBABILITY));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -396,9 +371,9 @@ public class TurnBasedMinecraftMod {
                                }
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.attackProbability = attackProbability;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -411,9 +386,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_VARIANCE));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_VARIANCE));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -430,9 +405,9 @@ public class TurnBasedMinecraftMod {
                                }
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.attackVariance = attackVariance;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -445,9 +420,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_EFFECT));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_EFFECT));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -461,9 +436,9 @@ public class TurnBasedMinecraftMod {
                                EntityInfo.Effect effect = EntityInfo.Effect.fromString(StringArgumentType.getString(c, "attackEffect"));
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.attackEffect = effect;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -476,9 +451,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_EFFECT_PROBABILITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_EFFECT_PROBABILITY));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -497,9 +472,9 @@ public class TurnBasedMinecraftMod {
                                }
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.attackEffectProbability = attackEffectProbability;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -512,9 +487,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DEFENSE_DAMAGE));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DEFENSE_DAMAGE));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -531,9 +506,9 @@ public class TurnBasedMinecraftMod {
                                }
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.defenseDamage = defenseDamage;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -546,9 +521,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DEFENSE_DAMAGE_PROBABILITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DEFENSE_DAMAGE_PROBABILITY));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -567,9 +542,9 @@ public class TurnBasedMinecraftMod {
                                }
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.defenseDamageProbability = defenseDamageProbability;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -582,9 +557,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_EVASION));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_EVASION));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -603,9 +578,9 @@ public class TurnBasedMinecraftMod {
                                }
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.evasion = evasion;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -618,9 +593,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_SPEED));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_SPEED));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -637,9 +612,9 @@ public class TurnBasedMinecraftMod {
                                }
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.speed = speed;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -652,9 +627,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_CATEGORY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_CATEGORY));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -668,9 +643,9 @@ public class TurnBasedMinecraftMod {
                                String category = StringArgumentType.getString(c, "category");
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.category = category;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -683,9 +658,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_ATTACK));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_ATTACK));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -704,9 +679,9 @@ public class TurnBasedMinecraftMod {
                                }
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.decisionAttack = decisionAttack;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -719,9 +694,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_DEFEND));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_DEFEND));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -740,9 +715,9 @@ public class TurnBasedMinecraftMod {
                                }
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.decisionDefend = decisionDefend;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -755,9 +730,9 @@ public class TurnBasedMinecraftMod {
                            ServerPlayer player = c.getSource().getPlayerOrException();
                            EditingInfo editingInfo = TurnBasedMinecraftMod.proxy.getEditingInfo(player.getId());
                            if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_FLEE));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_FLEE));
                            } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                            } else {
                                Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -771,9 +746,9 @@ public class TurnBasedMinecraftMod {
                                int decisionFlee = IntegerArgumentType.getInteger(c, "decisionFlee");
                                if (editingInfo != null && !editingInfo.isPendingEntitySelection) {
                                    editingInfo.entityInfo.decisionFlee = decisionFlee;
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo));
                                } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
                                } else {
                                    Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                    throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@ -789,7 +764,7 @@ public class TurnBasedMinecraftMod {
                .requires(c -> c.hasPermission(2))
                .executes(c -> {
                    ServerPlayer player = c.getSource().getPlayerOrException();
-                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.SERVER_EDIT));
+                    PacketDistributor.PLAYER.with(player).send(new PacketEditingMessage(PacketEditingMessage.Type.SERVER_EDIT));
                    return 1;
                })
                .then(Commands.literal("leave_battle_cooldown").executes(c -> {
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketBattleDecision.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketBattleDecision.java
@ -4,13 +4,17 @@ import com.burnedkirby.TurnBasedMinecraft.common.Battle;
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
 import com.burnedkirby.TurnBasedMinecraft.common.Battle.Decision;

-import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.network.FriendlyByteBuf;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
+import net.minecraft.world.entity.player.Player;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;

-public class PacketBattleDecision
+public class PacketBattleDecision implements CustomPacketPayload
 {
+    public static final ResourceLocation ID = new ResourceLocation(TurnBasedMinecraftMod.MODID, "network_packetbattledecision");
+
    private int battleID;
    private Battle.Decision decision;
    private int targetIDOrItemID;
@ -24,40 +28,43 @@ public class PacketBattleDecision
        this.targetIDOrItemID = targetIDOrItemID;
    }

-    public static class Encoder implements MessageFunctions.MessageEncoder<PacketBattleDecision> {
-        public Encoder() {}
-
-        @Override
-        public void encode(PacketBattleDecision pkt, FriendlyByteBuf buf) {
-            buf.writeInt(pkt.battleID);
-            buf.writeInt(pkt.decision.getValue());
-            buf.writeInt(pkt.targetIDOrItemID);
-        }
+    public PacketBattleDecision(final FriendlyByteBuf buf) {
+        this.battleID = buf.readInt();
+        this.decision = Decision.valueOf(buf.readInt());
+        this.targetIDOrItemID = buf.readInt();
    }

-    public static class Decoder implements MessageFunctions.MessageDecoder<PacketBattleDecision> {
-        public Decoder() {}
-
-        @Override
-        public PacketBattleDecision decode(FriendlyByteBuf buf) {
-            return new PacketBattleDecision(buf.readInt(), Decision.valueOf(buf.readInt()), buf.readInt());
-        }
+    @Override
+    public void write(FriendlyByteBuf buf) {
+        buf.writeInt(battleID);
+        buf.writeInt(decision.getValue());
+        buf.writeInt(targetIDOrItemID);
    }

-    public static class Consumer implements MessageFunctions.MessageConsumer<PacketBattleDecision> {
-        public Consumer() {}
+    @Override
+    public ResourceLocation id() {
+        return ID;
+    }

-        @Override
-        public void handle(PacketBattleDecision pkt, NetworkEvent.Context ctx) {
-            ctx.enqueueWork(() -> {
-                Battle b = TurnBasedMinecraftMod.proxy.getBattleManager().getBattleByID(pkt.battleID);
-                if(b != null)
-                {
-                    ServerPlayer player = ctx.getSender();
-                    b.setDecision(player.getId(), pkt.decision, pkt.targetIDOrItemID);
-                }
-            });
-            ctx.setPacketHandled(true);
+    public static class PayloadHandler {
+        private static final PayloadHandler INSTANCE = new PayloadHandler();
+
+        public static PayloadHandler getInstance() {
+            return INSTANCE;
+        }
+
+        public void handleData(final PacketBattleDecision pkt, final PlayPayloadContext ctx) {
+           ctx.workHandler().submitAsync(() -> {
+               Battle b = TurnBasedMinecraftMod.proxy.getBattleManager().getBattleByID(pkt.battleID);
+               if(b != null)
+               {
+                   Player player = ctx.player().get();
+                   b.setDecision(player.getId(), pkt.decision, pkt.targetIDOrItemID);
+               }
+           }).exceptionally(e -> {
+               ctx.packetHandler().disconnect(Component.literal("Exception handling PacketBattleDecision! " + e.getMessage()));
+               return null;
+           });
        }
    }
 }
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketBattleInfo.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketBattleInfo.java
@ -6,13 +6,16 @@ import java.util.Collection;
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;

 import net.minecraft.client.Minecraft;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.network.FriendlyByteBuf;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;

-public class PacketBattleInfo
+public class PacketBattleInfo implements CustomPacketPayload
 {
+    public static final ResourceLocation ID = new ResourceLocation(TurnBasedMinecraftMod.MODID, "network_packetbattleinfo");
    private Collection<Integer> sideA;
    private Collection<Integer> sideB;
    private long decisionNanos;
@ -38,53 +41,51 @@ public class PacketBattleInfo
        this.turnTimerEnabled = turnTimerEnabled;
    }

-    public static class Encoder implements MessageFunctions.MessageEncoder<PacketBattleInfo> {
-        public Encoder() {}
-
-        @Override
-        public void encode(PacketBattleInfo msg, FriendlyByteBuf buf) {
-            buf.writeInt(msg.sideA.size());
-            buf.writeInt(msg.sideB.size());
-            for(Integer id : msg.sideA) {
-                buf.writeInt(id);
-            }
-            for(Integer id : msg.sideB) {
-                buf.writeInt(id);
-            }
-            buf.writeLong(msg.decisionNanos);
-            buf.writeLong(msg.maxDecisionNanos);
-            buf.writeBoolean(msg.turnTimerEnabled);
+    public PacketBattleInfo(final FriendlyByteBuf buf) {
+        int sideACount = buf.readInt();
+        int sideBCount = buf.readInt();
+        this.sideA = new ArrayList<>(sideACount);
+        this.sideB = new ArrayList<>(sideBCount);
+        for (int i = 0; i < sideACount; ++i) {
+            this.sideA.add(buf.readInt());
        }
+        for (int i = 0; i < sideBCount; ++i) {
+            this.sideB.add(buf.readInt());
+        }
+        this.decisionNanos = buf.readLong();
+        this.maxDecisionNanos = buf.readLong();
+        this.turnTimerEnabled = buf.readBoolean();
    }

-    public static class Decoder implements MessageFunctions.MessageDecoder<PacketBattleInfo> {
-        public Decoder() {}
-
-        @Override
-        public PacketBattleInfo decode(FriendlyByteBuf buf) {
-            int sideACount = buf.readInt();
-            int sideBCount = buf.readInt();
-            Collection<Integer> sideA = new ArrayList<Integer>(sideACount);
-            Collection<Integer> sideB = new ArrayList<Integer>(sideBCount);
-            for(int i = 0; i < sideACount; ++i) {
-                sideA.add(buf.readInt());
-            }
-            for(int i = 0; i < sideBCount; ++i) {
-                sideB.add(buf.readInt());
-            }
-            long decisionNanos = buf.readLong();
-            long maxDecisionNanos = buf.readLong();
-            boolean turnTimerEnabled = buf.readBoolean();
-            return new PacketBattleInfo(sideA, sideB, decisionNanos, maxDecisionNanos, turnTimerEnabled);
+    @Override
+    public void write(FriendlyByteBuf buf) {
+        buf.writeInt(sideA.size());
+        buf.writeInt(sideB.size());
+        for(Integer id : sideA) {
+            buf.writeInt(id);
        }
+        for(Integer id : sideB) {
+            buf.writeInt(id);
+        }
+        buf.writeLong(decisionNanos);
+        buf.writeLong(maxDecisionNanos);
+        buf.writeBoolean(turnTimerEnabled);
    }

-    public static class Consumer implements MessageFunctions.MessageConsumer<PacketBattleInfo> {
-        public Consumer() {}
+    @Override
+    public ResourceLocation id() {
+        return ID;
+    }

-        @Override
-        public void handle(PacketBattleInfo pkt, NetworkEvent.Context ctx) {
-            ctx.enqueueWork(() -> {
+    public static class PayloadHandler {
+        private static final PayloadHandler INSTANCE = new PayloadHandler();
+
+        public static PayloadHandler getInstance() {
+            return INSTANCE;
+        }
+
+        public void handleData(final PacketBattleInfo pkt, final PlayPayloadContext ctx) {
+            ctx.workHandler().submitAsync(() -> {
                if(TurnBasedMinecraftMod.proxy.getLocalBattle() == null)
                {
                    return;
@ -110,8 +111,10 @@ public class PacketBattleInfo
                TurnBasedMinecraftMod.proxy.setBattleGuiBattleChanged();
                TurnBasedMinecraftMod.proxy.setBattleGuiTurnTimerEnabled(pkt.turnTimerEnabled);
                TurnBasedMinecraftMod.proxy.setBattleGuiTurnTimerMax((int)(pkt.maxDecisionNanos / 1000000000L));
+            }).exceptionally(e -> {
+                ctx.packetHandler().disconnect(Component.literal("Exception handling PacketBattleInfo! " + e.getMessage()));
+                return null;
            });
-            ctx.setPacketHandled(true);
        }
    }
 }
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketBattleMessage.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketBattleMessage.java
@ -7,14 +7,33 @@ import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;

 import com.burnedkirby.TurnBasedMinecraft.common.Utility;
 import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
 import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.Level;
 import net.neoforged.fml.loading.FMLEnvironment;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;

-public class PacketBattleMessage
+public class PacketBattleMessage implements CustomPacketPayload
 {
+    public static final ResourceLocation ID = new ResourceLocation(TurnBasedMinecraftMod.MODID, "network_packetbattlemessage");
+
+    @Override
+    public void write(FriendlyByteBuf buf) {
+        buf.writeInt(messageType.getValue());
+        buf.writeInt(entityIDFrom);
+        buf.writeInt(entityIDTo);
+        buf.writeUtf(Utility.serializeDimension(dimension));
+        buf.writeInt(amount);
+        buf.writeUtf(custom);
+    }
+
+    @Override
+    public ResourceLocation id() {
+        return ID;
+    }
+
    public enum MessageType
    {
        ENTERED(0),
@ -154,47 +173,31 @@ public class PacketBattleMessage
        this.custom = custom;
    }

-    public static class Encoder implements MessageFunctions.MessageEncoder<PacketBattleMessage> {
-        public Encoder() {}
-
-        @Override
-        public void encode(PacketBattleMessage pkt, FriendlyByteBuf buf) {
-            buf.writeInt(pkt.messageType.getValue());
-            buf.writeInt(pkt.entityIDFrom);
-            buf.writeInt(pkt.entityIDTo);
-            buf.writeUtf(Utility.serializeDimension(pkt.dimension));
-            buf.writeInt(pkt.amount);
-            buf.writeUtf(pkt.custom);
-        }
+    public PacketBattleMessage(final FriendlyByteBuf buf) {
+        this.messageType = MessageType.valueOf(buf.readInt());
+        this.entityIDFrom = buf.readInt();
+        this.entityIDTo = buf.readInt();
+        this.dimension = Utility.deserializeDimension(buf.readUtf());
+        this.amount = buf.readInt();
+        this.custom = buf.readUtf();
    }

-    public static class Decoder implements MessageFunctions.MessageDecoder<PacketBattleMessage> {
-        public Decoder() {}
+    public static class PayloadHandler {
+        private static final PayloadHandler INSTANCE = new PayloadHandler();

-        @Override
-        public PacketBattleMessage decode(FriendlyByteBuf buf) {
-            return new PacketBattleMessage(
-                MessageType.valueOf(
-                    buf.readInt()),
-                buf.readInt(),
-                buf.readInt(),
-                Utility.deserializeDimension(buf.readUtf()),
-                buf.readInt(),
-                buf.readUtf());
+        public static PayloadHandler getInstance() {
+            return INSTANCE;
        }
-    }

-    public static class Consumer implements MessageFunctions.MessageConsumer<PacketBattleMessage> {
-        public Consumer() {}
-
-        @Override
-        public void handle(PacketBattleMessage pkt, NetworkEvent.Context ctx) {
-            ctx.enqueueWork(() -> {
+        public void handleData(final PacketBattleMessage pkt, final PlayPayloadContext ctx) {
+            ctx.workHandler().submitAsync(() -> {
                if (FMLEnvironment.dist.isClient()) {
                    TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx);
                }
+            }).exceptionally(e -> {
+                ctx.packetHandler().disconnect(Component.literal("Exception handling PacketBattleMessage! " + e.getMessage()));
+                return null;
            });
-            ctx.setPacketHandled(true);
        }
    }
 }
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketBattleRequestInfo.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketBattleRequestInfo.java
@ -4,11 +4,15 @@ import com.burnedkirby.TurnBasedMinecraft.common.Battle;
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;

 import net.minecraft.network.FriendlyByteBuf;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;

-public class PacketBattleRequestInfo
+public class PacketBattleRequestInfo implements CustomPacketPayload
 {
+    public static final ResourceLocation ID = new ResourceLocation(TurnBasedMinecraftMod.MODID, "network_packetbattlerequestinfo");
+
    private int battleID;
    
    public PacketBattleRequestInfo() {}
@ -18,37 +22,43 @@ public class PacketBattleRequestInfo
        this.battleID = battleID;
    }

-    public static class Encoder implements MessageFunctions.MessageEncoder<PacketBattleRequestInfo> {
-        public Encoder() {}
-
-        @Override
-        public void encode(PacketBattleRequestInfo pkt, FriendlyByteBuf buf) {
-            buf.writeInt(pkt.battleID);
-        }
+    public PacketBattleRequestInfo(final FriendlyByteBuf buf) {
+        battleID = buf.readInt();
    }

-    public static class Decoder implements MessageFunctions.MessageDecoder<PacketBattleRequestInfo> {
-        public Decoder() {}
-
-        @Override
-        public PacketBattleRequestInfo decode(FriendlyByteBuf buf) {
-            return new PacketBattleRequestInfo(buf.readInt());
-        }
+    @Override
+    public void write(FriendlyByteBuf buf) {
+        buf.writeInt(battleID);
    }

-    public static class Consumer implements MessageFunctions.MessageConsumer<PacketBattleRequestInfo> {
-        public Consumer() {}
+    @Override
+    public ResourceLocation id() {
+        return ID;
+    }

-        @Override
-        public void handle(PacketBattleRequestInfo pkt, NetworkEvent.Context ctx) {
-            ctx.enqueueWork(() -> {
+    public static class PayloadHandler {
+        private static final PayloadHandler INSTANCE = new PayloadHandler();
+
+        public static PayloadHandler getInstance() {
+            return INSTANCE;
+        }
+
+        public void handleData(final PacketBattleRequestInfo pkt, final PlayPayloadContext ctx) {
+            ctx.workHandler().submitAsync(() -> {
                Battle b = TurnBasedMinecraftMod.proxy.getBattleManager().getBattleByID(pkt.battleID);
                if(b == null) {
                    return;
                }
-                TurnBasedMinecraftMod.getHandler().reply(new PacketBattleInfo(b.getSideAIDs(), b.getSideBIDs(), b.getTimerNanos(), TurnBasedMinecraftMod.proxy.getConfig().getDecisionDurationNanos(), !TurnBasedMinecraftMod.proxy.getConfig().isBattleDecisionDurationForever()), ctx);
+                ctx.replyHandler().send(new PacketBattleInfo(
+                    b.getSideAIDs(),
+                    b.getSideBIDs(),
+                    b.getTimerNanos(),
+                    TurnBasedMinecraftMod.proxy.getConfig().getDecisionDurationNanos(),
+                    !TurnBasedMinecraftMod.proxy.getConfig().isBattleDecisionDurationForever()));
+            }).exceptionally(e -> {
+                ctx.packetHandler().disconnect(Component.literal("Exception handling PacketBattleRequestInfo! " + e.getMessage()));
+                return null;
            });
-            ctx.setPacketHandled(true);
        }
    }
 }
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketEditingMessage.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketEditingMessage.java
@ -3,15 +3,49 @@ package com.burnedkirby.TurnBasedMinecraft.common.networking;
 import com.burnedkirby.TurnBasedMinecraft.common.EntityInfo;
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
 import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
 import net.neoforged.fml.loading.FMLEnvironment;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;

 import java.util.HashMap;
 import java.util.Map;

-public class PacketEditingMessage
+public class PacketEditingMessage implements CustomPacketPayload
 {
+    public static final ResourceLocation ID = new ResourceLocation(TurnBasedMinecraftMod.MODID, "network_packeteditingmessage");
+
+    @Override
+    public void write(FriendlyByteBuf buf) {
+        buf.writeInt(type.getValue());
+        if(entityInfo.classType != null) {
+            buf.writeUtf(entityInfo.classType.getName());
+        } else {
+            buf.writeUtf("unknown");
+        }
+        buf.writeBoolean(entityInfo.ignoreBattle);
+        buf.writeInt(entityInfo.attackPower);
+        buf.writeInt(entityInfo.attackProbability);
+        buf.writeInt(entityInfo.attackVariance);
+        buf.writeUtf(entityInfo.attackEffect.toString());
+        buf.writeInt(entityInfo.attackEffectProbability);
+        buf.writeInt(entityInfo.defenseDamage);
+        buf.writeInt(entityInfo.defenseDamageProbability);
+        buf.writeInt(entityInfo.evasion);
+        buf.writeInt(entityInfo.speed);
+        buf.writeUtf(entityInfo.category);
+        buf.writeInt(entityInfo.decisionAttack);
+        buf.writeInt(entityInfo.decisionDefend);
+        buf.writeInt(entityInfo.decisionFlee);
+        buf.writeUtf(entityInfo.customName);
+    }
+
+    @Override
+    public ResourceLocation id() {
+        return ID;
+    }
+
    public enum Type
    {
        ATTACK_ENTITY(0),
@ -87,75 +121,45 @@ public class PacketEditingMessage
        }
    }

-    public static class Encoder implements MessageFunctions.MessageEncoder<PacketEditingMessage> {
-        public Encoder() {}
-
-        @Override
-        public void encode(PacketEditingMessage pkt, FriendlyByteBuf buf) {
-            buf.writeInt(pkt.type.getValue());
-            if(pkt.entityInfo.classType != null) {
-                buf.writeUtf(pkt.entityInfo.classType.getName());
-            } else {
-                buf.writeUtf("unknown");
-            }
-            buf.writeBoolean(pkt.entityInfo.ignoreBattle);
-            buf.writeInt(pkt.entityInfo.attackPower);
-            buf.writeInt(pkt.entityInfo.attackProbability);
-            buf.writeInt(pkt.entityInfo.attackVariance);
-            buf.writeUtf(pkt.entityInfo.attackEffect.toString());
-            buf.writeInt(pkt.entityInfo.attackEffectProbability);
-            buf.writeInt(pkt.entityInfo.defenseDamage);
-            buf.writeInt(pkt.entityInfo.defenseDamageProbability);
-            buf.writeInt(pkt.entityInfo.evasion);
-            buf.writeInt(pkt.entityInfo.speed);
-            buf.writeUtf(pkt.entityInfo.category);
-            buf.writeInt(pkt.entityInfo.decisionAttack);
-            buf.writeInt(pkt.entityInfo.decisionDefend);
-            buf.writeInt(pkt.entityInfo.decisionFlee);
-            buf.writeUtf(pkt.entityInfo.customName);
-        }
+    public PacketEditingMessage(final FriendlyByteBuf buf) {
+        this.type = Type.valueOf(buf.readInt());
+        this.entityInfo = new EntityInfo();
+        try {
+            this.entityInfo.classType = this.entityInfo.getClass().getClassLoader().loadClass(buf.readUtf());
+        } catch (ClassNotFoundException e) { /* ignored */ }
+        this.entityInfo.ignoreBattle = buf.readBoolean();
+        this.entityInfo.attackPower = buf.readInt();
+        this.entityInfo.attackProbability = buf.readInt();
+        this.entityInfo.attackVariance = buf.readInt();
+        this.entityInfo.attackEffect = EntityInfo.Effect.fromString(buf.readUtf());
+        this.entityInfo.attackEffectProbability = buf.readInt();
+        this.entityInfo.defenseDamage = buf.readInt();
+        this.entityInfo.defenseDamageProbability = buf.readInt();
+        this.entityInfo.evasion = buf.readInt();
+        this.entityInfo.speed = buf.readInt();
+        this.entityInfo.category = buf.readUtf();
+        this.entityInfo.decisionAttack = buf.readInt();
+        this.entityInfo.decisionDefend = buf.readInt();
+        this.entityInfo.decisionFlee = buf.readInt();
+        this.entityInfo.customName = buf.readUtf();
    }

-    public static class Decoder implements MessageFunctions.MessageDecoder<PacketEditingMessage> {
-        public Decoder() {}
+    public static class PayloadHandler {
+        private static final PayloadHandler INSTANCE = new PayloadHandler();

-        @Override
-        public PacketEditingMessage decode(FriendlyByteBuf buf) {
-            Type type = Type.valueOf(buf.readInt());
-            EntityInfo einfo = new EntityInfo();
-            try {
-                einfo.classType = einfo.getClass().getClassLoader().loadClass(buf.readUtf());
-            } catch (ClassNotFoundException e) { /* ignored */ }
-            einfo.ignoreBattle = buf.readBoolean();
-            einfo.attackPower = buf.readInt();
-            einfo.attackProbability = buf.readInt();
-            einfo.attackVariance = buf.readInt();
-            einfo.attackEffect = EntityInfo.Effect.fromString(buf.readUtf());
-            einfo.attackEffectProbability = buf.readInt();
-            einfo.defenseDamage = buf.readInt();
-            einfo.defenseDamageProbability = buf.readInt();
-            einfo.evasion = buf.readInt();
-            einfo.speed = buf.readInt();
-            einfo.category = buf.readUtf();
-            einfo.decisionAttack = buf.readInt();
-            einfo.decisionDefend = buf.readInt();
-            einfo.decisionFlee = buf.readInt();
-            einfo.customName = buf.readUtf();
-            return new PacketEditingMessage(type, einfo);
+        public static PayloadHandler getInstance() {
+            return INSTANCE;
        }
-    }

-    public static class Consumer implements MessageFunctions.MessageConsumer<PacketEditingMessage> {
-        public Consumer() {}
-
-        @Override
-        public void handle(PacketEditingMessage pkt, NetworkEvent.Context ctx) {
-            ctx.enqueueWork(() -> {
+        public void handleData(final PacketEditingMessage pkt, final PlayPayloadContext ctx) {
+            ctx.workHandler().submitAsync(() -> {
                if (FMLEnvironment.dist.isClient()) {
                    TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx);
                }
+            }).exceptionally(e -> {
+                ctx.packetHandler().disconnect(Component.literal("Exception handling PacketEditingMessage! " + e.getMessage()));
+                return null;
            });
-            ctx.setPacketHandled(true);
        }
    }
-}
+}
--- a/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketGeneralMessage.java
+++ b/src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketGeneralMessage.java
@ -3,14 +3,16 @@ package com.burnedkirby.TurnBasedMinecraft.common.networking;
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;

 import net.minecraft.network.FriendlyByteBuf;
-import net.neoforged.api.distmarker.Dist;
-import net.neoforged.fml.DistExecutor;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
 import net.neoforged.fml.loading.FMLEnvironment;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.simple.MessageFunctions;
+import net.neoforged.neoforge.network.handling.PlayPayloadContext;

-public class PacketGeneralMessage
+public class PacketGeneralMessage implements CustomPacketPayload
 {
+    public static final ResourceLocation ID = new ResourceLocation(TurnBasedMinecraftMod.MODID, "network_packetgeneralmessage");
+
    String message;

    public String getMessage() {
@ -27,35 +29,36 @@ public class PacketGeneralMessage
        this.message = message;
    }

-    public static class Encoder implements MessageFunctions.MessageEncoder<PacketGeneralMessage> {
-        public Encoder() {}
-
-        @Override
-        public void encode(PacketGeneralMessage pkt, FriendlyByteBuf buf) {
-            buf.writeUtf(pkt.message);
-        }
+    public PacketGeneralMessage(final FriendlyByteBuf buf) {
+        this.message = buf.readUtf();
    }

-    public static class Decoder implements MessageFunctions.MessageDecoder<PacketGeneralMessage> {
-        public Decoder() {}
-
-        @Override
-        public PacketGeneralMessage decode(FriendlyByteBuf buf) {
-            return new PacketGeneralMessage(buf.readUtf());
-        }
+    @Override
+    public void write(FriendlyByteBuf buf) {
+        buf.writeUtf(message);
    }

-    public static class Consumer implements MessageFunctions.MessageConsumer<PacketGeneralMessage> {
-        public Consumer() {}
+    @Override
+    public ResourceLocation id() {
+        return ID;
+    }

-        @Override
-        public void handle(PacketGeneralMessage pkt, NetworkEvent.Context ctx) {
-            ctx.enqueueWork(() -> {
+    public static class PayloadHandler {
+        private static final PayloadHandler INSTANCE = new PayloadHandler();
+
+        public static PayloadHandler getInstance() {
+            return INSTANCE;
+        }
+
+        public void handleData(final PacketGeneralMessage pkt, final PlayPayloadContext ctx) {
+            ctx.workHandler().submitAsync(() -> {
                if (FMLEnvironment.dist.isClient()) {
                    TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx);
                }
+            }).exceptionally(e -> {
+                ctx.packetHandler().disconnect(Component.literal("Exception handling PacketGeneralMessage! " + e.getMessage()));
+                return null;
            });
-            ctx.setPacketHandled(true);
        }
    }
 }
--- a/src/main/resources/META-INF/mods.toml
+++ b/src/main/resources/META-INF/mods.toml
@ -9,7 +9,7 @@ modLoader="javafml" #mandatory
 loaderVersion="${loader_version_range}" #mandatory (34 is current forge version)
 # A URL to refer people to when problems occur with this mod
 issueTrackerURL="https://github.com/Stephen-Seo/TurnBasedMinecraftMod/issues" #optional
-license="MIT"
+license="${mod_license}"
 # A list of mods - how many allowed here is determined by the individual mod loader
 [[mods]] #mandatory
 # The modid of the mod
@ -29,15 +29,16 @@ credits="Thanks for this mod goes to Java" #optional
 # A text field displayed in the mod UI
 authors="${mod_authors}" #optional
 # The description text for the mod (multi line!) (#mandatory)
-description='''
-Implements turn-based-battle in Minecraft.
-'''
+description='''${mod_description}'''
+
+logoFile="assets/com_burnedkirby_turnbasedminecraft/tbmm_icon.png"
+
 # A dependency - use the . to indicate dependency for a specific modid. Dependencies are optional.
 [[dependencies.com_burnedkirby_turnbasedminecraft]] #optional
    # the modid of the dependency
    modId="neoforge" #mandatory
    # Does this dependency have to exist - if not, ordering below must be specified
-    mandatory=true #mandatory
+    type="required" #mandatory
    # The version range of the dependency
    versionRange="${neo_version_range}" #mandatory
    # An ordering relationship for the dependency - BEFORE or AFTER required if the relationship is not mandatory
@ -47,7 +48,7 @@ Implements turn-based-battle in Minecraft.
 # Here's another dependency
 [[dependencies.com_burnedkirby_turnbasedminecraft]]
    modId="minecraft"
-    mandatory=true
+    type="required"
    versionRange="${minecraft_version_range}"
    ordering="NONE"
    side="BOTH"
--- a/src/main/resources/assets/com_burnedkirby_turnbasedminecraft/tbmm_icon.png
+++ b/src/main/resources/assets/com_burnedkirby_turnbasedminecraft/tbmm_icon.png
--- a/src/main/resources/mcmod.info
+++ b/src/main/resources/mcmod.info
@ -1,18 +0,0 @@
-[
-{
-  "modid": "com_burnedkirby_turnbasedminecraft",
-  "name": "Turn Based Minecraft",
-  "description": "Changes battles to be turn-based.",
-  "version": "1.25.0",
-  "mcversion": "1.20.1",
-  "url": "",
-  "updateUrl": "",
-  "authorList": ["Stephen Seo"],
-  "credits": "The Forge and FML guys, for making this possible.
-    Dependencies:
-        JavaMP3 by delthas, josephx86, GlaDOSik, and kevinstadler (MIT License)",
-  "logoFile": "",
-  "screenshots": [],
-  "dependencies": []
-}
-]
Author	SHA1	Message	Date
Stephen Seo	bba99d4e6a	Update README.md	2024-01-30 11:14:01 +09:00
Stephen Seo	356502f722	Action: Check if release exists before releasing	2024-01-22 18:29:29 +09:00
Stephen Seo	75976c8d9a	Enable "any_archLinux" act runner for building jar	2024-01-20 20:01:54 +09:00
Stephen Seo	62774b0b0c	Fix Reproducibility.md Build TurnBasedMC and create Release / build-and-create-release (push) Successful in 6m57s Details	2024-01-17 14:51:42 +09:00
Stephen Seo	846840c3a7	Update README.md	2024-01-17 14:48:56 +09:00
Stephen Seo	43bb0c7059	Fix version in main mod class	2024-01-17 14:48:37 +09:00
Stephen Seo	288ed1cfd6	Update Reproducibility.md Build TurnBasedMC and create Release / build-and-create-release (push) Has been cancelled Details	2024-01-17 14:44:12 +09:00
Stephen Seo	b8a32a490e	Update Changelog.md	2024-01-17 14:43:21 +09:00
Stephen Seo	ae3cbfe4f6	Bump version to 1.25.2, cleanup of gradle stuff	2024-01-17 14:42:55 +09:00
Stephen Seo	9a481f95d0	Update Changelog.md	2024-01-17 14:30:19 +09:00
Stephen Seo	24a29eaba6	Update Reproducibility.md	2024-01-17 14:29:31 +09:00
Stephen Seo	9fab572800	Fix usage of throwable potions in battle Add (experimental) "right-click" support for items when "Use" is invoked on an item in battle.	2024-01-17 14:29:19 +09:00
Stephen Seo	6f0c223c9d	Update FAQ.md	2024-01-17 13:43:24 +09:00
Stephen Seo	17c39a5329	Update README.md	2024-01-17 13:38:59 +09:00
Stephen Seo	4879aaefd1	Update README.md	2024-01-17 13:35:09 +09:00
Stephen Seo	46f8e22c8b	Update Changelog.md, Reproducibility.md	2024-01-16 22:20:09 +09:00
Stephen Seo	54afb08263	Update Reproducibility.md Build TurnBasedMC and create Release / build-and-create-release (push) Successful in 5m57s Details	2024-01-16 17:29:55 +09:00
Stephen Seo	2616e73407	Update Changelog.md	2024-01-16 17:24:22 +09:00
Stephen Seo	edc3246bd1	Minor fixes to ItemSelectionButton	2024-01-16 17:10:24 +09:00
Stephen Seo	b1b8451331	Update .gitignore	2024-01-16 16:58:48 +09:00
Stephen Seo	f635badfe1	Bump version to 1.25.1	2024-01-16 16:58:39 +09:00
Stephen Seo	fb2c4cd13c	Update code for NeoForge 20.4.108-beta	2024-01-16 16:55:13 +09:00
Stephen Seo	830f4255bb	Update Changelog.md	2024-01-16 14:15:29 +09:00
Stephen Seo	490518a58a	Add "icon" for mod	2024-01-16 14:15:13 +09:00
Stephen Seo	e3ba1abdae	Remove unused mcmod.info file	2024-01-16 14:14:45 +09:00
Stephen Seo	d564756c42	"Pin" j-ogg-vorbis version	2024-01-11 16:30:58 +09:00
Stephen Seo	64a7fb263f	Tweak to forgejo action/workflow	2024-01-10 11:56:54 +09:00
Stephen Seo	52b1b5ee05	Minor tweak to FAQ.md	2024-01-09 11:16:06 +09:00
Stephen Seo	2e71ea97ad	Minor fix to build-jar action/workflow	2024-01-08 18:34:00 +09:00
Stephen Seo	f9178777ee	Update README.md	2024-01-08 18:24:39 +09:00
Stephen Seo	9d4cd5c4e7	Update LICENSE year	2024-01-08 18:20:57 +09:00
Stephen Seo	85c4588470	Update FAQ.md	2024-01-08 17:31:03 +09:00
Stephen Seo	7770698947	Update README.md	2024-01-08 17:27:45 +09:00
Stephen Seo	a3d4ae74ef	Add FAQ.md	2024-01-08 17:25:43 +09:00