Update Changelog.md, Reproducibility.md

MC Version 1.20.4

.forgejo/workflows/build-jar.yaml

@@ -0,0 +1,37 @@
+name: Build TurnBasedMC and create Release
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  build-and-create-release:
+    runs-on: 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}
+      - run: cd TurnBasedMinecraftMod && sed -i '/org.gradle.jvmargs/s/Xmx[0-9]\+m/Xmx1024m/' gradle.properties
+      - run: cd TurnBasedMinecraftMod && ./gradlew --console=plain build
+      - run: cd TurnBasedMinecraftMod/build/libs && find . -type f -exec sha256sum '{}' ';' -exec bash -c 'sha256sum {} >> sha256sums.txt' ';' && java --version >> javaVersion.txt && javac --version >> javaVersion.txt
+      - name: Create release and attach jar
+        run: |
+          curl --fail-with-body -X 'POST' \
+          "https://git.seodisparate.com/api/v1/repos/stephenseo/TurnBasedMinecraftMod/releases" \
+          -H 'accept: application/json' \
+          -H "Authorization: token ${GITHUB_TOKEN}" \
+          -H 'Content-Type: application/json' \
+          -d "{
+          \"name\": \"TurnBasedMinecraftMod version ${GITHUB_REF_NAME}\",
+          \"body\": \"See the [Changelog](https://git.seodisparate.com/stephenseo/TurnBasedMinecraftMod/src/branch/master/Changelog.md)
+
+              $(java --version | sed -n '1p;2,$s/^/    /p')
+              $(javac --version)
+              $(find TurnBasedMinecraftMod/build/libs -regex '.*all.jar$' -exec sha256sum '{}' ';')\",
+          \"tag_name\": \"${GITHUB_REF_NAME}\"
+          }" > response.json \
+          && curl --fail-with-body -X 'POST' \
+          "https://git.seodisparate.com/api/v1/repos/stephenseo/TurnBasedMinecraftMod/releases/$(jq .id < response.json)/assets" \
+          -H 'accept: application/json' \
+          -H "Authorization: token ${GITHUB_TOKEN}" \
+          -H 'Content-Type: multipart/form-data' \
+          -F "attachment=@$(find TurnBasedMinecraftMod/build/libs -regex '.*all.jar$');type=application/java-archive" > response2.json

.gitignore

@@ -22,3 +22,4 @@ eclipse
 run
 
 logs/
+runs/

Changelog.md

@@ -1,5 +1,49 @@
 # Upcoming changes
 
+# 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`.
+
+Implement playing Vorbis encoded .ogg files for battle/silly music.
+
+# Version Forge-1.25.0
+
+Remove usage of "shadow jar" in build.gradle, and use jarJar instead.
+
+Add new dependency `j-ogg-vorbis`.
+
+Implement playing Vorbis encoded .ogg files for battle/silly music.
+
+# Version NeoForge-1.24.0
+
+Update to NeoForge 1.20.2-20.2.88.
+
+Allow use of Crossbows in battle (it should behave identically to Bows).
+
+# Version Forge-1.24.0
+
+Update to Forge 1.20.2-48.1.0.
+
+The `master` branch of this repository will track the build for Minecraft Forge.
+
+The `neoforge` branch of this repo. will track the build for NeoForge.
+
+Allow use of Crossbows in battle (it should behave identically to Bows).
+
 # Version 1.23.1
 
 More robust handling of disallowed Damage Sources in battle (via config).

FAQ.md

@@ -0,0 +1,73 @@
+## 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.**
+
+## 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.

LICENSE

@@ -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

README.md

@@ -8,9 +8,13 @@ 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
 
-(Once modrinth.com has approved this mod, the modrinth page of this mod will be
+# Forge or NeoForge
-linked here.)
+
+The `master` branch tracks the version of the mod for Minecraft Forge.
+
+The `neoforge` branch tracks the version of the mod for Minecraft NeoForge.
 
 # What changed in what version
 
@@ -41,14 +45,19 @@ When playing multiplayer, some configuration of the config on the server may be
 between them
 - Supports use of the vanilla Minecraft bow and arrows (have bow selected when
 in battle)
-- Supports custom battle music to be played when fighting enemies. (They must be
+- Supports custom battle music to be played when fighting enemies. (They must
-placed in `.minecraft/config/TurnBasedMinecraft/Music/battle` or
+  be placed in `.minecraft/config/TurnBasedMinecraft/Music/battle` or
-`.minecraft/config/TurnBasedMinecraft/Music/silly`. Client-side config determines
+  `.minecraft/config/TurnBasedMinecraft/Music/silly`. Client-side config
-which song plays in battle for the client. only `.wav`, ~~`.mid`~~, and `.mp3` files
+  determines which song plays in battle for the client. only `.wav`,
-supported.  ~~Only `.mid` files are not affected by volume options (master and
+  ~~`.mid`~~, `.mp3`, and `.ogg` files supported.  ~~Only `.mid` files are not
-music sliders))~~ Midi file playback has been disabled for now due to lack of volume
+  affected by volume options (master and music sliders))~~ Midi file playback
-control issues. MP3 file playback sometimes fails, but seems to work better when the
+  has been disabled for now due to lack of volume control issues. MP3 file
-file is as "barebones" as possible (no album art metadata in the 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`.
 - 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
@@ -61,16 +70,27 @@ configured for them.)
 # Building
 
 Simply invoke `./gradlew build` in the mod directory and after some time the
-finished jar will be saved at "build/libs/TurnBasedMinecraft-1.23.1.jar"
+finished jar will be saved at
+`build/libs/TurnBasedMinecraft-Forge-1.25.1-all.jar`
+
+# Reproducibility
+
+This mod should support reproducible builds. See `Reproducibility.md` to see
+more details.
 
 # Other notes
 
-This mod uses [shadow](https://github.com/johnrengelman/shadow) which is
+This mod uses [j-ogg-vorbis](https://github.com/stephengold/j-ogg-all) available
-licenced under the [Apache License 2.0](https://github.com/johnrengelman/shadow/blob/master/LICENSE).
+from [http://www.j-ogg.de](http://www.j-ogg.de) and copyrighted by 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/)

Reproducibility.md

@@ -0,0 +1,83 @@
+# Reproducibility
+
+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.
+
+## 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
+    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.0-all.jar
+    0e5eacc8aefd3b1a1c8e6c9657108172934fae2e727547ca7c12f9ff79ce4e8e  build/libs/TurnBasedMinecraft-NeoForge-1.25.0-all.jar
+
+## Forge 1.25.0
+
+    $ 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.0-all.jar
+    51ef854552b180df68969f4cec6fdc8716ef519b947948b9e5f4ce9953d00162  build/libs/TurnBasedMinecraft-Forge-1.25.0-all.jar
+
+## NeoForge 1.24.0
+
+    $ 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.24.0-all.jar
+    584935b6e928ad141a55e4d1a21944cebff5152396782085d145bbe34c29286c  build/libs/TurnBasedMinecraft-NeoForge-1.24.0-all.jar
+
+## Forge 1.24.0
+
+    $ 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.24.0.jar
+    e17c370cdf347b053c7f55091afed77564dcd8f419615bd6ca87babe10329c07  build/libs/TurnBasedMinecraft-Forge-1.24.0.jar

build.gradle

@@ -2,17 +2,18 @@ plugins {
     id 'eclipse'
     id 'idea'
     id 'maven-publish'
-    id 'net.minecraftforge.gradle' version '[6.0,6.2)'
+    id 'net.minecraftforge.gradle' version '[6.0.16,6.2)'
-    id 'com.github.johnrengelman.shadow' version '8.1.1'
 }
 
-version = "1.23.1"
+version = mod_version
-group = "com.burnedkirby.TurnBasedMinecraft"
+group = mod_group_id
-archivesBaseName = "TurnBasedMinecraft"
+archivesBaseName = "TurnBasedMinecraft-Forge"
 
 java.toolchain.languageVersion = JavaLanguageVersion.of(17)
 println('Java: ' + System.getProperty('java.version') + ' JVM: ' + System.getProperty('java.vm.version') + '(' + System.getProperty('java.vendor') + ') Arch: ' + System.getProperty('os.arch'))
 
+jarJar.enable()
+
 minecraft {
     // The mappings can be changed at any time, and must be in the following format.
     // snapshot_YYYYMMDD   Snapshot are built nightly.
@@ -32,48 +33,8 @@ minecraft {
     // Default run configurations.
     // These can be tweaked, removed, or duplicated as needed.
     runs {
-        client {
+        // applies to all the run configs below
-            workingDirectory project.file('run')
+        configureEach {
-
-            // Recommended logging data for a userdev environment
-            property 'forge.logging.markers', 'REGISTRIES'
-
-            // Recommended logging level for the console
-            property 'forge.logging.console.level', 'debug'
-
-            // Comma-separated list of namespaces to load gametests from. Empty = all namespaces.
-            property 'forge.enabledGameTestNamespaces', 'TurnBasedMinecraftMod'
-
-            mods {
-                TurnBasedMinecraftMod {
-                    source sourceSets.main
-                }
-            }
-        }
-
-        server {
-            workingDirectory project.file('run')
-
-            // Recommended logging data for a userdev environment
-            property 'forge.logging.markers', 'REGISTRIES'
-
-            // Recommended logging level for the console
-            property 'forge.logging.console.level', 'debug'
-
-            // Comma-separated list of namespaces to load gametests from. Empty = all namespaces.
-            property 'forge.enabledGameTestNamespaces', 'TurnBasedMinecraftMod'
-
-            mods {
-                TurnBasedMinecraftMod {
-                    source sourceSets.main
-                }
-            }
-        }
-
-        // This run config launches GameTestServer and runs all registered gametests, then exits.
-        // By default, the server will crash when no gametests are provided.
-        // The gametest system is also enabled by default for other run configs under the /test command.
-        gameTestServer {
             workingDirectory project.file('run')
 
             // Recommended logging data for a userdev environment
@@ -87,33 +48,31 @@ minecraft {
             // You can set various levels here.
             // Please read: https://stackoverflow.com/questions/2031163/when-to-use-the-different-log-levels
             property 'forge.logging.console.level', 'debug'
+        }
 
+        client {
             // Comma-separated list of namespaces to load gametests from. Empty = all namespaces.
-            property 'forge.enabledGameTestNamespaces', 'TurnBasedMinecraftMod'
+            property 'forge.enabledGameTestNamespaces', mod_id
+        }
 
-            mods {
+        server {
-                TurnBasedMinecraftMod {
+            property 'forge.enabledGameTestNamespaces', mod_id
-                    source sourceSets.main
+            args '--nogui'
-                }
+        }
-            }
+
+        // This run config launches GameTestServer and runs all registered gametests, then exits.
+        // By default, the server will crash when no gametests are provided.
+        // The gametest system is also enabled by default for other run configs under the /test command.
+        gameTestServer {
+            property 'forge.enabledGameTestNamespaces', mod_id
         }
 
         data {
-            workingDirectory project.file('run')
+            // example of overriding the workingDirectory set in configureEach above
+            workingDirectory project.file('run-data')
 
-            // Recommended logging data for a userdev environment
+            // Specify the modid for data generation, where to output the resulting resource, and where to look for existing resources.
-            property 'forge.logging.markers', 'REGISTRIES'
+            args '--mod', mod_id, '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources/')
-
-            // Recommended logging level for the console
-            property 'forge.logging.console.level', 'debug'
-
-            args '--mod', 'TurnBasedMinecraftMod', '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources')
-
-            mods {
-                TurnBasedMinecraftMod {
-                    source sourceSets.main
-                }
-            }
         }
     }
 }
@@ -121,49 +80,31 @@ minecraft {
 // Include resources generated by data generators.
 sourceSets.main.resources { srcDir 'src/generated/resources' }
 
-//repositories {
+repositories {
-//    // Put repositories for dependencies here
+    flatDir {
-//    // ForgeGradle automatically adds the Forge maven and Maven Central for you
+        dir 'libs'
-//
+    }
-//    // If you have mod jar dependencies in ./libs, you can declare them as a repository like so:
-//    // flatDir {
-//    //     dir 'libs'
-//    // }
-//    mavenCentral()
-//    jcenter()
-//
-//    dependencies {
-//        classpath 'com.github.jengelman.gradle.plugins:shadow:4.0.4'
-//    }
-//}
-
-apply plugin: 'com.github.johnrengelman.shadow'
-
-configurations {
-    shade
-    impelmentation.extendsFrom shade
 }
 
 dependencies {
-    // Specify the version of Minecraft to use, If this is any group other then 'net.minecraft' it is assumed
+    // Specify the version of Minecraft to use.
-    // that the dep is a ForgeGradle 'patcher' dependency. And it's patches will be applied.
+    // Any artifact can be supplied so long as it has a "userdev" classifier artifact and is a compatible patcher artifact.
-    // The userdev artifact is a special name and will get all sorts of transformations applied to it.
+    // The "userdev" classifier will be requested and setup by ForgeGradle.
+    // If the group id is "net.minecraft" and the artifact id is one of ["client", "server", "joined"],
+    // then special handling is done to allow a setup of a vanilla dependency without the use of an external repository.
     minecraft "net.minecraftforge:forge:${minecraft_version}-${forge_version}"
 
-    // Real mod deobf dependency examples - these get remapped to your current mappings
+    implementation 'fr.delthas:javamp3:1.0.3'
-    // compileOnly fg.deobf("mezz.jei:jei-${mc_version}:${jei_version}:api") // Adds JEI API as a compile dependency
-    // runtimeOnly fg.deobf("mezz.jei:jei-${mc_version}:${jei_version}") // Adds the full JEI mod as a runtime dependency
-    // implementation fg.deobf("com.tterrag.registrate:Registrate:MC${mc_version}-${registrate_version}") // Adds registrate as a dependency
 
-    // Examples using mod jars from ./libs
+    implementation 'com.github.stephengold:j-ogg-vorbis:1.0.4'
-    // implementation fg.deobf("blank:coolmod-${mc_version}:${coolmod_version}")
 
-    // For more info...
+    jarJar(group: 'fr.delthas', name: 'javamp3', version: '[1.0.0,2.0.0)') {
-    // http://www.gradle.org/docs/current/userguide/artifact_dependencies_tutorial.html
+        jarJar.pin(it, '1.0.3')
-    // http://www.gradle.org/docs/current/userguide/dependency_management.html
+    }
-    implementation files('libs/javamp3-1.0.3.jar')
 
-    shade files('libs/javamp3-1.0.3.jar')
+    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.
@@ -185,36 +126,21 @@ tasks.named('processResources', ProcessResources).configure {
     }
 }
 
-// Example for how to get properties into the manifest for reading by the runtime..
+// Example for how to get properties into the manifest for reading at runtime.
-jar {
+tasks.named('jar', Jar).configure {
-    archiveClassifier = 'slim'
     manifest {
         attributes([
-            "Specification-Title": "TurnBasedMinecraftMod",
+            'Specification-Title'     : mod_id,
-            "Specification-Vendor": "TurnBasedMinecraftMod_BK",
+            'Specification-Vendor'    : mod_authors,
-            "Specification-Version": "1", // We are version 1 of ourselves
+            'Specification-Version'   : '1', // We are version 1 of ourselves
-            "Implementation-Title": project.name,
+            'Implementation-Title'    : "TurnBasedMinecraftMod",
-            "Implementation-Version": "${version}",
+            'Implementation-Version'  : project.jar.archiveVersion,
-            "Implementation-Vendor" :"TurnBasedMinecraftMod_BK",
+            'Implementation-Vendor'   : mod_authors
-            // 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"
         ])
     }
-}
 
-shadowJar {
+    // This is the preferred method to reobfuscate your jar file
-    archiveClassifier = ''
+    finalizedBy 'reobfJar'
-    //project.configurations.shadow.setTransitive(true);
-    configurations = [project.configurations.shade]
-    relocate 'fr.delthas', 'com.burnedkirby.tbm_repack.fr.delthas'
-    finalizedBy 'reobfShadowJar'
-}
-
-assemble.dependsOn shadowJar
-
-reobf {
-    shadowJar {} // reobfuscate the shadowed jar
 }
 
 // Reproducible Builds
@@ -223,24 +149,16 @@ tasks.withType(AbstractArchiveTask).configureEach {
     reproducibleFileOrder = true
 }
 
-// Example configuration to allow publishing using the maven-publish task
+tasks.withType(JavaCompile).configureEach {
-// we define a custom artifact that is sourced from the reobfJar output task
+    options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
-// and then declare that to be published
+}
-// Note you'll need to add a repository here
+
-//def reobfFile = file("$buildDir/reobfJar/output.jar")
+// Merge the resources and classes into the same directory. 
-//def reobfArtifact = artifacts.add('default', reobfFile) {
+// This is done because java expects modules to be in a single directory.
-//    type 'jar'
+// And if we have it in multiple we have to do performance intensive hacks like having the UnionFileSystem
-//    builtBy 'reobfJar'
+// This will eventually be migrated to ForgeGradle so modders don't need to manually do it. But that is later.
-//}
+sourceSets.each {
-//publishing {
+    def dir = layout.buildDirectory.dir("sourcesSets/$it.name")
-//    publications {
+    it.output.resourcesDir = dir
-//        mavenJava(MavenPublication) {
+    it.java.destinationDirectory = dir
-//            artifact reobfArtifact
+}
-//        }
-//    }
-//    repositories {
-//        maven {
-//            url "file:///${project.projectDir}/mcmodsrepo"
-//        }
-//    }
-//}

gradle.properties

@@ -4,17 +4,17 @@ org.gradle.daemon=false
 ## Environment Properties
 
 # The Minecraft version must agree with the Forge version to get a valid artifact
-minecraft_version=1.20.1
+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.1,1.21)
+minecraft_version_range=[1.20.4,1.21)
 # The Forge version must agree with the Minecraft version to get a valid artifact
-forge_version=47.1.0
+forge_version=49.0.19
 # The Forge version range can use any version of Forge as bounds or match the loader version range
-forge_version_range=[47,)
+forge_version_range=[0,)
 # The loader version range can only use the major version of Forge/FML as bounds
-loader_version_range=[47,)
+loader_version_range=[0,)
 # The mapping channel to use for mappings.
 # The default set of supported mapping channels are ["official", "snapshot", "snapshot_nodoc", "stable", "stable_nodoc"].
 # Additional mapping channels can be registered through the "channelProviders" extension in a Gradle plugin.
@@ -32,7 +32,7 @@ loader_version_range=[47,)
 mapping_channel=official
 # The mapping version to query from the mapping channel.
 # This must match the format required by the mapping channel.
-mapping_version=1.20.1
+mapping_version=1.20.4
 
 ## Mod Properties
 
@@ -44,11 +44,11 @@ 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.23.1
+mod_version=1.25.1
 # 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.

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-all.zip
 networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

settings.gradle

@@ -11,5 +11,5 @@ pluginManagement {
 }
 
 plugins {
-    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.5.0'
+    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.7.0'
 }

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.minecraftforge.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) -> {
+				addRenderableWidget(new ItemSelectionButton(width / 2 - 88 + i * 20, height - 19, 16, 16, i, (button) -> {
-					buttonActionEvent(button, ButtonAction.DO_ITEM_SWITCH);
+					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) -> {
+				addRenderableWidget(new ItemSelectionButton(width / 2 - 88 + i * 20, height - 19, 16, 16, i, (button) -> {
-					buttonActionEvent(button, ButtonAction.DO_USE_ITEM);
+					itemButtonActionEvent(button, ButtonAction.DO_USE_ITEM);
 				}));
 			}
 			addRenderableWidget(Button.builder(Component.literal("Cancel"), (button) -> {
@@ -275,27 +275,23 @@ public class BattleGui extends Screen {
 			setState(MenuState.ATTACK_TARGET);
 			break;
 		case DEFEND:
-			TurnBasedMinecraftMod.getHandler().sendToServer(new PacketBattleDecision(
+			TurnBasedMinecraftMod.getHandler().send(new PacketBattleDecision(
-					TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.DEFEND, 0));
+				TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.DEFEND, 0),
+				PacketDistributor.SERVER.noArg());
 			setState(MenuState.WAITING);
 			break;
 		case ITEM:
 			setState(MenuState.ITEM_ACTION);
 			break;
 		case FLEE:
-			TurnBasedMinecraftMod.getHandler().sendToServer(new PacketBattleDecision(
+			TurnBasedMinecraftMod.getHandler().send(new PacketBattleDecision(
-					TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.FLEE, 0));
+				TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.FLEE, 0),
+				PacketDistributor.SERVER.noArg());
 			setState(MenuState.WAITING);
 			break;
 		case ATTACK_TARGET:
-			if (button instanceof EntitySelectionButton) {
+			// Invalid but set to main menu anyways.
-				TurnBasedMinecraftMod.getHandler()
+			setState(MenuState.MAIN_MENU);
-						.sendToServer(new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
-								Battle.Decision.ATTACK, ((EntitySelectionButton) button).getID()));
-				setState(MenuState.WAITING);
-			} else {
-				setState(MenuState.MAIN_MENU);
-			}
 			break;
 		case SWITCH_HELD_ITEM:
 			setState(MenuState.SWITCH_ITEM);
@@ -307,31 +303,50 @@ public class BattleGui extends Screen {
 			setState(MenuState.MAIN_MENU);
 			break;
 		case DO_ITEM_SWITCH:
-			if (button instanceof ItemSelectionButton) {
+			// Invalid but set to main menu anyways.
-				TurnBasedMinecraftMod.getHandler()
+			setState(MenuState.MAIN_MENU);
-						.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);
-			}
 			break;
 		case DO_USE_ITEM:
-			if (button instanceof ItemSelectionButton) {
+			// Invalid, but set menu to main menu anyways.
-				TurnBasedMinecraftMod.getHandler()
+			setState(MenuState.MAIN_MENU);
-						.sendToServer(new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(),
-								Battle.Decision.USE_ITEM, ((ItemSelectionButton) button).getID()));
-				setState(MenuState.WAITING);
-			} else {
-				setState(MenuState.MAIN_MENU);
-			}
 			break;
 		}
 	}
 
+	protected void entityButtonActionEvent(EntitySelectionButton button, ButtonAction action) {
+		if (action.equals(ButtonAction.ATTACK_TARGET)) {
+			TurnBasedMinecraftMod.getHandler().send(new PacketBattleDecision(
+					TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.ATTACK, button.getID()),
+				PacketDistributor.SERVER.noArg());
+			setState(MenuState.WAITING);
+		} else {
+			setState(MenuState.MAIN_MENU);
+		}
+	}
+
+	protected void itemButtonActionEvent(ItemSelectionButton button, ButtonAction action) {
+		switch (action) {
+			case DO_ITEM_SWITCH:
+				TurnBasedMinecraftMod.getHandler().send(
+					new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.SWITCH_ITEM, button.getID()),
+					PacketDistributor.SERVER.noArg());
+				if (button.getID() >= 0 && button.getID() < 9) {
+					Minecraft.getInstance().player.getInventory().selected = button.getID();
+				}
+				setState(MenuState.WAITING);
+				break;
+			case DO_USE_ITEM:
+				TurnBasedMinecraftMod.getHandler().send(
+					new PacketBattleDecision(TurnBasedMinecraftMod.proxy.getLocalBattle().getId(), Battle.Decision.USE_ITEM, button.getID()),
+					PacketDistributor.SERVER.noArg());
+				setState(MenuState.WAITING);
+				break;
+			default:
+				setState(MenuState.MAIN_MENU);
+				break;
+		}
+	}
+
 	@Override
 	public boolean isPauseScreen() {
 		return false;
@@ -345,6 +360,11 @@ public class BattleGui extends Screen {
 		return false; // TODO verify return value
 	}
 
+	@Override
+	public void renderBackground(GuiGraphics p_283688_, int p_299421_, int p_298679_, float p_297268_) {
+		// Left blank to not render background.
+	}
+
 	@Override
 	public boolean keyReleased(int a, int b, int c) {
 		if (getMinecraft().player.isCreative()) {

src/main/java/com/burnedkirby/TurnBasedMinecraft/client/BattleMusic.java

@@ -1,6 +1,7 @@
 package com.burnedkirby.TurnBasedMinecraft.client;
 
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
+import de.jarnbjo.vorbis.VorbisAudioFileReader;
 import fr.delthas.javamp3.Sound;
 import net.minecraft.client.Minecraft;
 import org.apache.logging.log4j.Logger;
@@ -28,7 +29,9 @@ public class BattleMusic
     private boolean playingIsSilly;
     private boolean isPlaying;
     private Thread mp3StreamThread;
+    private Thread oggVorbisStreamThread;
     private MP3Streamer mp3StreamRunnable;
+    private OGGVorbisStreamer oggVorbisStreamRunnable;
 
     public BattleMusic(Logger logger)
     {
@@ -81,7 +84,7 @@ public class BattleMusic
                 }
                 String ext = name.substring(extIndex + 1).toLowerCase();
 //                return ext.equals("mid") || ext.equals("wav") || ext.equals("mp3");
-                return ext.equals("wav") || ext.equals("mp3"); // midi disabled
+                return ext.equals("wav") || ext.equals("mp3") || ext.equals("ogg"); // midi disabled
             }
         });
         for(File f : battleFiles)
@@ -101,7 +104,7 @@ public class BattleMusic
                 }
                 String ext = name.substring(extIndex + 1).toLowerCase();
 //                return ext.equals("mid") || ext.equals("wav") || ext.equals("mp3");
-                return ext.equals("wav") || ext.equals("mp3"); // midi disabled
+                return ext.equals("wav") || ext.equals("mp3") || ext.equals("ogg"); // midi disabled
             }
         });
         for(File f : sillyFiles)
@@ -303,6 +306,39 @@ public class BattleMusic
                     return;
                 }
             }
+            else if (suffix.equals("ogg")) {
+                if(sequencer != null && sequencer.isRunning())
+                {
+                    sequencer.stop();
+                }
+                if(clip != null && clip.isActive())
+                {
+                    clip.stop();
+                    clip.close();
+                }
+                if(mp3StreamThread != null && mp3StreamThread.isAlive())
+                {
+                    mp3StreamRunnable.setKeepPlaying(false);
+                    try { mp3StreamThread.join(); } catch (Throwable t) { /* ignored */ }
+                }
+
+                try {
+                    if (oggVorbisStreamRunnable == null) {
+                        oggVorbisStreamRunnable = new OGGVorbisStreamer(next, logger, volume);
+                    } else {
+                        oggVorbisStreamRunnable.setOggVorbisFile(next);
+                        oggVorbisStreamRunnable.setVolume(volume);
+                    }
+
+                    oggVorbisStreamThread = new Thread(oggVorbisStreamRunnable);
+                    oggVorbisStreamThread.start();
+                    logger.info("Started playing OggVorbis " + next.getName());
+                } catch (Throwable t) {
+                    logger.error("Failed to play battle music (ogg)");
+                    t.printStackTrace();
+                    return;
+                }
+            }
         }
     }
     
@@ -320,6 +356,10 @@ public class BattleMusic
             mp3StreamRunnable.setKeepPlaying(false);
             try { mp3StreamThread.join(); } catch (Throwable t) { /* ignored */ }
         }
+        if (oggVorbisStreamThread != null && oggVorbisStreamThread.isAlive()) {
+            oggVorbisStreamRunnable.setKeepPlaying(false);
+            try { oggVorbisStreamThread.join(); } catch (Throwable t) { /* ignored */ }
+        }
         if(resumeMCSounds)
         {
             Minecraft.getInstance().getSoundManager().resume();
@@ -454,4 +494,93 @@ public class BattleMusic
             }
         }
     }
+
+    private class OGGVorbisStreamer implements Runnable {
+        private AtomicBoolean keepPlaying;
+        private File oggVorbisFile;
+        private Logger logger;
+        private float volume;
+
+        public OGGVorbisStreamer(File oggVorbisFile, Logger logger, float volume) {
+            keepPlaying = new AtomicBoolean(true);
+            this.oggVorbisFile = oggVorbisFile;
+            this.logger = logger;
+            this.volume = volume;
+            if (this.volume > 1.0F) {
+                this.volume = 1.0F;
+            } else if (this.volume < 0.0F) {
+                this.volume = 0.0F;
+            }
+        }
+
+        public void setKeepPlaying(boolean playing) {
+            keepPlaying.set(playing);
+        }
+
+        public void setOggVorbisFile(File oggVorbisFile) {
+            this.oggVorbisFile = oggVorbisFile;
+        }
+
+        public void setVolume(float volume) {
+            this.volume = volume;
+        }
+
+        @Override
+        public void run() {
+            keepPlaying.set(true);
+            SourceDataLine sdl = null;
+            try {
+                VorbisAudioFileReader reader = new VorbisAudioFileReader();
+                AudioFormat audioFormat = reader.getAudioFileFormat(oggVorbisFile).getFormat();
+                sdl = AudioSystem.getSourceDataLine(audioFormat);
+                sdl.open(audioFormat);
+                {
+                    FloatControl volumeControl = (FloatControl) sdl.getControl(FloatControl.Type.MASTER_GAIN);
+                    volumeControl.setValue(volume * 20.0f - 20.0f); // in decibels
+                }
+
+                AudioInputStream ais = reader.getAudioInputStream(oggVorbisFile);
+
+                ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                byte[] cached = null;
+                int cachedOffset = 0;
+                int cachedSize = 0;
+                byte[] buf = new byte[4096];
+                sdl.start();
+                int read = ais.read(buf);
+                while (keepPlaying.get()) {
+                    if (baos != null) {
+                        if (read != -1) {
+                            sdl.write(buf, 0, read);
+                            baos.write(buf, 0, read);
+                            read = ais.read(buf);
+                        } else {
+                            ais.close();
+                            ais = null;
+                            cached = baos.toByteArray();
+                            baos = null;
+                        }
+                    } else {
+                        cachedSize = cached.length - cachedOffset;
+                        if (cachedSize > 4096) {
+                            cachedSize = 4096;
+                        }
+                        sdl.write(cached, cachedOffset, cachedSize);
+                        cachedOffset += cachedSize;
+                        if (cachedOffset >= cached.length) {
+                            cachedOffset = 0;
+                        }
+                    }
+                }
+            } catch (Throwable t) {
+                logger.error("Stream play oggVorbis", t);
+            }
+
+            if (sdl != null) {
+                sdl.stop();
+                sdl.flush();
+                sdl.close();
+            }
+        }
+    }
 }

src/main/java/com/burnedkirby/TurnBasedMinecraft/client/ClientProxy.java

@@ -15,9 +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.minecraftforge.network.NetworkEvent;
+import net.minecraftforge.event.network.CustomPayloadEvent;
-
-import java.util.function.Supplier;
 
 public class ClientProxy extends CommonProxy {
     private BattleGui battleGui = null;
@@ -224,7 +222,7 @@ public class ClientProxy extends CommonProxy {
     }
 
     @Override
-    public <MSG> void handlePacket(MSG msg, Supplier<NetworkEvent.Context> ctx) {
+    public <MSG> void handlePacket(MSG msg, CustomPayloadEvent.Context ctx) {
         if (msg.getClass() == PacketBattleMessage.class) {
             PacketBattleMessage pkt = (PacketBattleMessage) msg;
             Entity fromEntity = getEntity(pkt.getEntityIDFrom(), pkt.getDimension());
@@ -436,6 +434,12 @@ public class ClientProxy extends CommonProxy {
                     TurnBasedMinecraftMod.proxy.displayComponent(parentComponent);
                 }
                 break;
+                case CROSSBOW_NO_AMMO: {
+                    parentComponent.getSiblings().add(from);
+                    parentComponent.getSiblings().add(Component.literal(" tried to use their crossbow but ran out of ammo!"));
+                    TurnBasedMinecraftMod.proxy.displayComponent(parentComponent);
+                }
+                break;
             }
         } else if (msg.getClass() == PacketGeneralMessage.class) {
             PacketGeneralMessage pkt = (PacketGeneralMessage) msg;

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 {
+public class EntitySelectionButton implements Renderable, GuiEventListener, NarratableEntry {
-    TBMButtonPress onPress;
+    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) {
+    public EntitySelectionButton(int x, int y, int widthIn, int heightIn, String buttonText, int entityID, boolean isSideA, TBMEntityButtonPress onPress) {
-        super(x, y, widthIn, heightIn, Component.literal(buttonText));
+        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) {
+    public EntitySelectionButton(int x, int y, int widthIn, int heightIn, Component buttonTextComponent, int entityID, boolean isSideA, TBMEntityButtonPress onPress) {
-        super(x, y, widthIn, heightIn, buttonTextComponent);
+        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, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
-                guiGraphics.fill(xpos, getY() + getHeight() * 3 / 5, xpos + 2, getY() + getHeight() * 4 / 5, 0xFFFFFF00);
+                guiGraphics.fill(xpos, this.y + this.height * 3 / 5, xpos + 2, this.y + this.height * 4 / 5, 0xFFFFFF00);
-                guiGraphics.fill(xpos, getY() + getHeight() * 2 / 5, xpos + 2, getY() + getHeight() * 3 / 5, 0xFF00FF00);
+                guiGraphics.fill(xpos, this.y + this.height * 2 / 5, xpos + 2, this.y + this.height * 3 / 5, 0xFF00FF00);
-                guiGraphics.fill(xpos, getY() + getHeight() / 5, xpos + 2, getY() + getHeight() * 2 / 5, 0xFF00FFFF);
+                guiGraphics.fill(xpos, this.y + this.height / 5, xpos + 2, this.y + this.height * 2 / 5, 0xFF00FFFF);
-                guiGraphics.fill(xpos, getY(), xpos + 2, getY() + getHeight() / 5, 0xFF0000FF);
+                guiGraphics.fill(xpos, this.y, xpos + 2, this.y + this.height / 5, 0xFF0000FF);
-                int healthHeight = ((health - 200) * getHeight() / 100);
+                int healthHeight = ((health - 200) * this.height / 100);
-                guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFFFFFFFF);
+                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, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
-                guiGraphics.fill(xpos, getY() + getHeight() * 3 / 5, xpos + 2, getY() + getHeight() * 4 / 5, 0xFFFFFF00);
+                guiGraphics.fill(xpos, this.y + this.height * 3 / 5, xpos + 2, this.y + this.height * 4 / 5, 0xFFFFFF00);
-                guiGraphics.fill(xpos, getY() + getHeight() * 2 / 5, xpos + 2, getY() + getHeight() * 3 / 5, 0xFF00FF00);
+                guiGraphics.fill(xpos, this.y + this.height * 2 / 5, xpos + 2, this.y + this.height * 3 / 5, 0xFF00FF00);
-                guiGraphics.fill(xpos, getY() + getHeight() / 5, xpos + 2, getY() + getHeight() * 2 / 5, 0xFF00FFFF);
+                guiGraphics.fill(xpos, this.y + this.height / 5, xpos + 2, this.y + this.height * 2 / 5, 0xFF00FFFF);
-                int healthHeight = ((health - 100) * getHeight() / 100);
+                int healthHeight = ((health - 100) * this.height / 100);
-                guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFF0000FF);
+                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, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
-                guiGraphics.fill(xpos, getY() + getHeight() * 3 / 5, xpos + 2, getY() + getHeight() * 4 / 5, 0xFFFFFF00);
+                guiGraphics.fill(xpos, this.y + this.height * 3 / 5, xpos + 2, this.y + this.height * 4 / 5, 0xFFFFFF00);
-                guiGraphics.fill(xpos, getY() + getHeight() * 2 / 5, xpos + 2, getY() + getHeight() * 3 / 5, 0xFF00FF00);
+                guiGraphics.fill(xpos, this.y + this.height * 2 / 5, xpos + 2, this.y + this.height * 3 / 5, 0xFF00FF00);
-                int healthHeight = ((health - 50) * getHeight() / 50);
+                int healthHeight = ((health - 50) * this.height / 50);
-                guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFF00FFFF);
+                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, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
-                guiGraphics.fill(xpos, getY() + getHeight() * 3 / 5, xpos + 2, getY() + getHeight() * 4 / 5, 0xFFFFFF00);
+                guiGraphics.fill(xpos, this.y + this.height * 3 / 5, xpos + 2, this.y + this.height * 4 / 5, 0xFFFFFF00);
-                int healthHeight = ((health - 20) * getHeight() / 30);
+                int healthHeight = ((health - 20) * this.height / 30);
-                guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFF00FF00);
+                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);
+                guiGraphics.fill(xpos, this.y + this.height * 4 / 5, xpos + 2, this.y + this.height, 0xFFFF0000);
-                int healthHeight = ((health - 10) * getHeight() / 10);
+                int healthHeight = ((health - 10) * this.height / 10);
-                guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFFFFFF00);
+                guiGraphics.fill(xpos + xoffset, this.y + this.height - healthHeight, xpos + xoffset + 2, this.y + this.height, 0xFFFFFF00);
             } else {
-                int healthHeight = (health * getHeight() / 10);
+                int healthHeight = (health * this.height / 10);
-                guiGraphics.fill(xpos + xoffset, getY() + getHeight() - healthHeight, xpos + xoffset + 2, getY() + getHeight(), 0xFFFF0000);
+                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;
+    }
 }

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 {
+public class ItemSelectionButton implements Renderable, GuiEventListener, NarratableEntry {
-
+    private int x;
-    TBMButtonPress onPress;
+    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) {
+    public ItemSelectionButton(int x, int y, int widthIn, int heightIn, int itemStackID, TBMItemButtonPress onPress) {
-        super(x, y, widthIn, heightIn, Component.literal(buttonText));
+        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 >= this.x && mouseY >= this.y && mouseX < this.x + this.width && mouseY < this.y + this.height;
-            boolean hovered = mouseX >= getX() && mouseY >= getY() && mouseX < getX() + getWidth() && mouseY < getY() + getHeight();
+        if (hovered) {
-            if (hovered) {
+            guiGraphics.fill(this.x, this.y, this.x + this.width, this.y + this.height, 0x80FFFFFF);
-                guiGraphics.fill(getX(), getY(), getX() + getWidth(), getY() + getHeight(), 0x80FFFFFF);
+        } else {
-            } else {
+            guiGraphics.fill(this.x, this.y, this.x + this.width, this.y + this.height, 0x20707070);
-                guiGraphics.fill(getX(), getY(), getX() + getWidth(), getY() + getHeight(), 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;
+    }
 }

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);
+}

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);
+}

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"));
+                            TurnBasedMinecraftMod.getHandler().send(new PacketGeneralMessage("Cannot edit custom name from entity without custom name"), PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor));
                             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() + "\""));
+                        TurnBasedMinecraftMod.getHandler().send(new PacketGeneralMessage("Editing custom name \"" + event.getEntity().getCustomName().getString() + "\""), PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor));
                         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));
+                        TurnBasedMinecraftMod.getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor));
                     }
                     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() + "\""));
+                        TurnBasedMinecraftMod.getHandler().send(new PacketGeneralMessage("Editing entity \"" + editingInfo.entityInfo.classType.getName() + "\""), PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor));
                         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));
+                        TurnBasedMinecraftMod.getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with((ServerPlayer)editingInfo.editor));
                     }
                     return;
                 }

src/main/java/com/burnedkirby/TurnBasedMinecraft/common/Battle.java

@@ -4,6 +4,7 @@ import com.burnedkirby.TurnBasedMinecraft.common.networking.PacketBattleInfo;
 import com.burnedkirby.TurnBasedMinecraft.common.networking.PacketBattleMessage;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
 import net.minecraft.world.damagesource.DamageSource;
 import net.minecraft.world.effect.MobEffects;
 import net.minecraft.world.entity.Entity;
@@ -448,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);
+            TurnBasedMinecraftMod.getHandler().send(infoPacket, PacketDistributor.PLAYER.with((ServerPlayer)p.entity));
         }
     }
 
@@ -463,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);
+                TurnBasedMinecraftMod.getHandler().send(packet, PacketDistributor.PLAYER.with((ServerPlayer)p.entity));
             }
         }
     }
@@ -573,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));
+            TurnBasedMinecraftMod.getHandler().send(new PacketBattleMessage(PacketBattleMessage.MessageType.ENDED, 0, 0, dimension, 0), PacketDistributor.PLAYER.with((ServerPlayer)c.entity));
         }
         battleManager.addRecentlyLeftBattle(c);
     }
@@ -793,6 +794,29 @@ public class Battle {
                                         sendMessageToAllPlayers(PacketBattleMessage.MessageType.BOW_NO_AMMO, next.entity.getId(), 0, 0);
                                     }
                                     continue;
+                                } else if (heldItemStack.getItem() instanceof CrossbowItem) {
+                                    debugLog += " with crossbow";
+                                    if (Utility.doesPlayerHaveArrows((Player)next.entity)) {
+                                        // Similar to attack with bow.
+                                        final Entity nextEntity = next.entity;
+                                        final Entity targetEntity = target.entity;
+                                        final float yawDirection = Utility.yawDirection(next.entity.getX(), next.entity.getZ(), target.entity.getX(), target.entity.getZ());
+                                        final float pitchDirection = Utility.pitchDirection(next.entity.getX(), next.entity.getY(), next.entity.getZ(), target.entity.getX(), target.entity.getY(), target.entity.getZ());
+                                        if (TurnBasedMinecraftMod.proxy.getConfig().isFreezeCombatantsEnabled()) {
+                                            next.yaw = yawDirection;
+                                            next.pitch = pitchDirection;
+                                        }
+                                        // have player look at attack target
+                                        ((ServerPlayer) nextEntity).connection.teleport(nextEntity.getX(), nextEntity.getY(), nextEntity.getZ(), yawDirection, pitchDirection);
+                                        CrossbowItem itemCrossbow = (CrossbowItem) heldItemStack.getItem();
+                                        TurnBasedMinecraftMod.proxy.getAttackerViaBowSet().add(new AttackerViaBow(nextEntity, getId()));
+                                        itemCrossbow.releaseUsing(((Player) nextEntity).getMainHandItem(), nextEntity.level(), (LivingEntity) nextEntity, -100);
+                                        itemCrossbow.use(nextEntity.level(), (Player)nextEntity, InteractionHand.MAIN_HAND);
+                                        sendMessageToAllPlayers(PacketBattleMessage.MessageType.FIRED_ARROW, nextEntity.getId(), targetEntity.getId(), 0);
+                                    } else {
+                                        sendMessageToAllPlayers(PacketBattleMessage.MessageType.CROSSBOW_NO_AMMO, next.entity.getId(), 0, 0);
+                                    }
+                                    continue;
                                 }
                                 debugLog += " without bow";
                                 int hitChance = TurnBasedMinecraftMod.proxy.getConfig().getPlayerAttackProbability();

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!"));
+            TurnBasedMinecraftMod.getHandler().send(new PacketGeneralMessage("You just left battle! " + config.getLeaveBattleCooldownSeconds() + " seconds until you can attack/be-attacked again!"), PacketDistributor.PLAYER.with((ServerPlayer)c.entity));
         }
         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."));
+                    TurnBasedMinecraftMod.getHandler().send(new PacketGeneralMessage("Timer ended, you can now attack/be-attacked again."), PacketDistributor.PLAYER.with((ServerPlayer)entry.getValue().entity));
                 }
             }
         }

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.minecraftforge.network.NetworkEvent;
+import net.minecraftforge.event.network.CustomPayloadEvent;
 import net.minecraftforge.server.ServerLifecycleHooks;
 import org.apache.logging.log4j.Logger;
 
@@ -13,7 +13,6 @@ import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.Map;
 import java.util.Set;
-import java.util.function.Supplier;
 
 public class CommonProxy
 {
@@ -173,5 +172,5 @@ public class CommonProxy
         return ServerLifecycleHooks.getCurrentServer().getLevel(dim).getEntity(id);
     }
 
-    public <MSG> void handlePacket(MSG msg, Supplier<NetworkEvent.Context> ctx) {}
+    public <MSG> void handlePacket(MSG msg,CustomPayloadEvent.Context ctx) {}
 }

src/main/java/com/burnedkirby/TurnBasedMinecraft/common/DimensionChangedHandler.java

@@ -15,8 +15,8 @@ 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"),
-                    new PacketGeneralMessage("Left battle due to moving to a different dimension"));
+                PacketDistributor.PLAYER.with((ServerPlayer)event.getEntity()));
         }
     }
 }

src/main/java/com/burnedkirby/TurnBasedMinecraft/common/TurnBasedMinecraftMod.java

@@ -29,9 +29,7 @@ import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
 import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
 import net.minecraftforge.fml.event.lifecycle.FMLDedicatedServerSetupEvent;
 import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
-import net.minecraftforge.network.NetworkRegistry;
+import net.minecraftforge.network.*;
-import net.minecraftforge.network.PacketDistributor;
-import net.minecraftforge.network.simple.SimpleChannel;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -39,7 +37,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.23.1";
+    public static final String VERSION = "1.25.1";
     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/";
@@ -50,13 +48,14 @@ public class TurnBasedMinecraftMod {
     public static final String MUSIC_SILLY = MUSIC_ROOT + "silly/";
     public static final String MUSIC_BATTLE = MUSIC_ROOT + "battle/";
 
-    private static final String PROTOCOL_VERSION = Integer.toString(2);
+    private static final Integer PROTOCOL_VERSION = 3;
     private static final ResourceLocation HANDLER_ID = new ResourceLocation(MODID, "main_channel");
-    private static final SimpleChannel HANDLER = NetworkRegistry.ChannelBuilder
+
+    private static final SimpleChannel HANDLER = ChannelBuilder
         .named(HANDLER_ID)
-        .clientAcceptedVersions(PROTOCOL_VERSION::equals)
+        .clientAcceptedVersions(Channel.VersionTest.exact(PROTOCOL_VERSION))
-        .serverAcceptedVersions(PROTOCOL_VERSION::equals)
+        .serverAcceptedVersions(Channel.VersionTest.exact(PROTOCOL_VERSION))
-        .networkProtocolVersion(() -> PROTOCOL_VERSION)
+        .networkProtocolVersion(PROTOCOL_VERSION)
         .simpleChannel();
     protected static Logger logger = LogManager.getLogger();
 
@@ -79,48 +78,41 @@ public class TurnBasedMinecraftMod {
     }
 
     private void firstInit(final FMLCommonSetupEvent event) {
-        proxy = DistExecutor.safeRunForDist(() -> ClientProxy::new, () -> CommonProxy::new);
+        proxy = DistExecutor.unsafeRunForDist(() -> () -> new ClientProxy(), () -> () -> new CommonProxy());
         proxy.setLogger(logger);
         proxy.initialize();
 
         // register packets
-        int packetHandlerID = 0;
+        HANDLER.messageBuilder(PacketBattleInfo.class, NetworkDirection.PLAY_TO_CLIENT)
-        HANDLER.registerMessage(
+            .encoder(new PacketBattleInfo.Encoder())
-            packetHandlerID++,
+            .decoder(new PacketBattleInfo.Decoder())
-            PacketBattleInfo.class,
+            .consumerNetworkThread(new PacketBattleInfo.Consumer())
-            PacketBattleInfo::encode,
+            .add();
-            PacketBattleInfo::decode,
+        HANDLER.messageBuilder(PacketBattleRequestInfo.class, NetworkDirection.PLAY_TO_SERVER)
-            PacketBattleInfo::handle);
+            .encoder(new PacketBattleRequestInfo.Encoder())
-        HANDLER.registerMessage(
+            .decoder(new PacketBattleRequestInfo.Decoder())
-            packetHandlerID++,
+            .consumerNetworkThread(new PacketBattleRequestInfo.Consumer())
-            PacketBattleRequestInfo.class,
+            .add();
-            PacketBattleRequestInfo::encode,
+        HANDLER.messageBuilder(PacketBattleDecision.class, NetworkDirection.PLAY_TO_SERVER)
-            PacketBattleRequestInfo::decode,
+            .encoder(new PacketBattleDecision.Encoder())
-            PacketBattleRequestInfo::handle);
+            .decoder(new PacketBattleDecision.Decoder())
-        HANDLER.registerMessage(
+            .consumerNetworkThread(new PacketBattleDecision.Consumer())
-            packetHandlerID++,
+            .add();
-            PacketBattleDecision.class,
+        HANDLER.messageBuilder(PacketBattleMessage.class, NetworkDirection.PLAY_TO_CLIENT)
-            PacketBattleDecision::encode,
+            .encoder(new PacketBattleMessage.Encoder())
-            PacketBattleDecision::decode,
+            .decoder(new PacketBattleMessage.Decoder())
-            PacketBattleDecision::handle);
+            .consumerNetworkThread(new PacketBattleMessage.Consumer())
-        HANDLER.registerMessage(
+            .add();
-            packetHandlerID++,
+        HANDLER.messageBuilder(PacketGeneralMessage.class, NetworkDirection.PLAY_TO_CLIENT)
-            PacketBattleMessage.class,
+            .encoder(new PacketGeneralMessage.Encoder())
-            PacketBattleMessage::encode,
+            .decoder(new PacketGeneralMessage.Decoder())
-            PacketBattleMessage::decode,
+            .consumerNetworkThread(new PacketGeneralMessage.Consumer())
-            PacketBattleMessage::handle);
+            .add();
-        HANDLER.registerMessage(
+        HANDLER.messageBuilder(PacketEditingMessage.class, NetworkDirection.PLAY_TO_CLIENT)
-            packetHandlerID++,
+            .encoder(new PacketEditingMessage.Encoder())
-            PacketGeneralMessage.class,
+            .decoder(new PacketEditingMessage.Decoder())
-            PacketGeneralMessage::encode,
+            .consumerNetworkThread(new PacketEditingMessage.Consumer())
-            PacketGeneralMessage::decode,
+            .add();
-            PacketGeneralMessage::handle);
-        HANDLER.registerMessage(
-            packetHandlerID++,
-            PacketEditingMessage.class,
-            PacketEditingMessage::encode,
-            PacketEditingMessage::decode,
-            PacketEditingMessage::handle);
 
         // register event handler(s)
         MinecraftForge.EVENT_BUS.register(new AttackEventHandler());
@@ -172,7 +164,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"));
+                        getHandler().send(new PacketGeneralMessage("OP disabled turn-based-combat for everyone"), PacketDistributor.PLAYER.with(player));
                     }
                     return 1;
                 }));
@@ -193,7 +185,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"));
+                        getHandler().send(new PacketGeneralMessage("OP enabled turn-based-combat for everyone"), PacketDistributor.PLAYER.with(player));
                     }
                     return 1;
                 }));
@@ -204,7 +196,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"));
+                        getHandler().send(new PacketGeneralMessage("OP enabled turn-based-combat for you"), PacketDistributor.PLAYER.with(player));
                         c.getSource().sendSuccess(() -> Component.literal("Enabled turn-based-combat for " + player.getDisplayName().getString()), true);
                     }
                     return 1;
@@ -216,7 +208,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"));
+                        getHandler().send(new PacketGeneralMessage("OP disabled turn-based-combat for you"), PacketDistributor.PLAYER.with(player));
                         c.getSource().sendSuccess(() -> Component.literal("Disabled turn-based-combat for " + player.getDisplayName().getString()), true);
                     }
                     return 1;
@@ -229,12 +221,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));
+                        getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                     } else if (editingInfo != null) {
-                        getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                        getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                     } else {
                         proxy.setEditingPlayer(player);
-                        getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                        getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                         logger.info("Begin editing TBM Entity for player \"" + player.getDisplayName().getString() + "\" (\"" + c.getSource().getDisplayName() + "\")");
                     }
                     return 1;
@@ -245,14 +237,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"));
+                                getHandler().send(new PacketGeneralMessage("An error occurred while attempting to save an entry to the config"), PacketDistributor.PLAYER.with(player));
                                 proxy.removeEditingInfo(player.getId());
                             } else {
                                 proxy.removeEditingInfo(player.getId());
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketGeneralMessage("Entity info saved in config and loaded."));
+                                getHandler().send(new PacketGeneralMessage("Entity info saved in config and loaded."), PacketDistributor.PLAYER.with(player));
                             }
                         } else if (editingInfo != null) {
-                            getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                            getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                         } else {
                             Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                             throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -265,7 +257,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."));
+                            getHandler().send(new PacketGeneralMessage("Cancelled editing entry."), PacketDistributor.PLAYER.with(player));
                         }
                         return 1;
                     }))
@@ -277,11 +269,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));
+                            getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                         } else {
                             proxy.setEditingPlayer(player);
                             proxy.getEditingInfo(player.getId()).isEditingCustomName = true;
-                            getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                            getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             logger.info("Begin editing custom TBM Entity for player \"" + player.getDisplayName().getString() + "\" (\"" + c.getSource().getDisplayName() + "\")");
                         }
                         return 1;
@@ -291,9 +283,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));
+                            getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                         } else if (editingInfo != null) {
-                            getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                            getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                         } else {
                             Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                             throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -305,9 +297,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_IGNORE_BATTLE), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -321,9 +313,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -336,9 +328,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_POWER), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -355,9 +347,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -370,9 +362,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_PROBABILITY), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -391,9 +383,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -406,9 +398,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_VARIANCE), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -425,9 +417,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -440,9 +432,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_EFFECT), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -456,9 +448,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -471,9 +463,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_ATTACK_EFFECT_PROBABILITY), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -492,9 +484,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -507,9 +499,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DEFENSE_DAMAGE), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -526,9 +518,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -541,9 +533,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DEFENSE_DAMAGE_PROBABILITY), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -562,9 +554,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -577,9 +569,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_EVASION), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -598,9 +590,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -613,9 +605,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_SPEED), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -632,9 +624,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -647,9 +639,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_CATEGORY), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -663,9 +655,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -678,9 +670,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_ATTACK), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -699,9 +691,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -714,9 +706,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_DEFEND), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -735,9 +727,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -750,9 +742,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));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.EDIT_DECISION_FLEE), PacketDistributor.PLAYER.with(player));
                             } else if (editingInfo != null) {
-                                getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                             } else {
                                 Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                 throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -766,9 +758,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));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.PICK_EDIT, editingInfo.entityInfo), PacketDistributor.PLAYER.with(player));
                                 } else if (editingInfo != null) {
-                                    getHandler().send(PacketDistributor.PLAYER.with(() -> player), new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY));
+                                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.ATTACK_ENTITY), PacketDistributor.PLAYER.with(player));
                                 } else {
                                     Message exceptionMessage = new LiteralMessage("Cannot edit entity without starting editing (use \"/tbm-edit\").");
                                     throw new CommandSyntaxException(new SimpleCommandExceptionType(exceptionMessage), exceptionMessage);
@@ -784,7 +776,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));
+                    getHandler().send(new PacketEditingMessage(PacketEditingMessage.Type.SERVER_EDIT), PacketDistributor.PLAYER.with(player));
                     return 1;
                 })
                 .then(Commands.literal("leave_battle_cooldown").executes(c -> {

src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketBattleDecision.java

@@ -1,6 +1,7 @@
 package com.burnedkirby.TurnBasedMinecraft.common.networking;
 
-import java.util.function.Supplier;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 import com.burnedkirby.TurnBasedMinecraft.common.Battle;
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
@@ -8,7 +9,7 @@ import com.burnedkirby.TurnBasedMinecraft.common.Battle.Decision;
 
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.network.NetworkEvent;
+import net.minecraftforge.event.network.CustomPayloadEvent;
 
 public class PacketBattleDecision
 {
@@ -25,25 +26,40 @@ public class PacketBattleDecision
         this.targetIDOrItemID = targetIDOrItemID;
     }
 
-    public static void encode(PacketBattleDecision pkt, FriendlyByteBuf buf) {
+    public static class Encoder implements BiConsumer<PacketBattleDecision, FriendlyByteBuf> {
-    	buf.writeInt(pkt.battleID);
+        public Encoder() {}
-    	buf.writeInt(pkt.decision.getValue());
+
-    	buf.writeInt(pkt.targetIDOrItemID);
+        @Override
+        public void accept(PacketBattleDecision pkt, FriendlyByteBuf buf) {
+            buf.writeInt(pkt.battleID);
+            buf.writeInt(pkt.decision.getValue());
+            buf.writeInt(pkt.targetIDOrItemID);
+        }
     }
 
-    public static PacketBattleDecision decode(FriendlyByteBuf buf) {
+    public static class Decoder implements Function<FriendlyByteBuf, PacketBattleDecision> {
-    	return new PacketBattleDecision(buf.readInt(), Decision.valueOf(buf.readInt()), buf.readInt());
+        public Decoder() {}
+
+        @Override
+        public PacketBattleDecision apply(FriendlyByteBuf buf) {
+            return new PacketBattleDecision(buf.readInt(), Decision.valueOf(buf.readInt()), buf.readInt());
+        }
     }
 
-    public static void handle(final PacketBattleDecision pkt, Supplier<NetworkEvent.Context> ctx) {
+    public static class Consumer implements BiConsumer<PacketBattleDecision, CustomPayloadEvent.Context> {
-        ctx.get().enqueueWork(() -> {
+        public Consumer() {}
-            Battle b = TurnBasedMinecraftMod.proxy.getBattleManager().getBattleByID(pkt.battleID);
+
-            if(b != null)
+        @Override
-            {
+        public void accept(PacketBattleDecision pkt, CustomPayloadEvent.Context ctx) {
-                ServerPlayer player = ctx.get().getSender();
+            ctx.enqueueWork(() -> {
-                b.setDecision(player.getId(), pkt.decision, pkt.targetIDOrItemID);
+                Battle b = TurnBasedMinecraftMod.proxy.getBattleManager().getBattleByID(pkt.battleID);
-            }
+                if(b != null)
-        });
+                {
-        ctx.get().setPacketHandled(true);
+                    ServerPlayer player = ctx.getSender();
+                    b.setDecision(player.getId(), pkt.decision, pkt.targetIDOrItemID);
+                }
+            });
+            ctx.setPacketHandled(true);
+        }
     }
 }

src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketBattleInfo.java

@@ -2,14 +2,15 @@ package com.burnedkirby.TurnBasedMinecraft.common.networking;
 
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.function.Supplier;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
 
 import net.minecraft.client.Minecraft;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.network.NetworkEvent;
+import net.minecraftforge.event.network.CustomPayloadEvent;
 
 public class PacketBattleInfo
 {
@@ -38,65 +39,80 @@ public class PacketBattleInfo
         this.turnTimerEnabled = turnTimerEnabled;
     }
 
-    public static void encode(PacketBattleInfo msg, FriendlyByteBuf buf) {
+    public static class Encoder implements BiConsumer<PacketBattleInfo, FriendlyByteBuf> {
-    	buf.writeInt(msg.sideA.size());
+        public Encoder() {}
-    	buf.writeInt(msg.sideB.size());
+
-    	for(Integer id : msg.sideA) {
+        @Override
-    		buf.writeInt(id);
+        public void accept(PacketBattleInfo msg, FriendlyByteBuf buf) {
-    	}
+            buf.writeInt(msg.sideA.size());
-    	for(Integer id : msg.sideB) {
+            buf.writeInt(msg.sideB.size());
-    		buf.writeInt(id);
+            for(Integer id : msg.sideA) {
-    	}
+                buf.writeInt(id);
-    	buf.writeLong(msg.decisionNanos);
+            }
-        buf.writeLong(msg.maxDecisionNanos);
+            for(Integer id : msg.sideB) {
-        buf.writeBoolean(msg.turnTimerEnabled);
+                buf.writeInt(id);
+            }
+            buf.writeLong(msg.decisionNanos);
+            buf.writeLong(msg.maxDecisionNanos);
+            buf.writeBoolean(msg.turnTimerEnabled);
+        }
     }
 
-    public static PacketBattleInfo decode(FriendlyByteBuf buf) {
+    public static class Decoder implements Function<FriendlyByteBuf, PacketBattleInfo> {
-    	int sideACount = buf.readInt();
+        public Decoder() {}
-    	int sideBCount = buf.readInt();
+
-    	Collection<Integer> sideA = new ArrayList<Integer>(sideACount);
+        @Override
-    	Collection<Integer> sideB = new ArrayList<Integer>(sideBCount);
+        public PacketBattleInfo apply(FriendlyByteBuf buf) {
-    	for(int i = 0; i < sideACount; ++i) {
+            int sideACount = buf.readInt();
-    		sideA.add(buf.readInt());
+            int sideBCount = buf.readInt();
-    	}
+            Collection<Integer> sideA = new ArrayList<Integer>(sideACount);
-    	for(int i = 0; i < sideBCount; ++i) {
+            Collection<Integer> sideB = new ArrayList<Integer>(sideBCount);
-    		sideB.add(buf.readInt());
+            for(int i = 0; i < sideACount; ++i) {
-    	}
+                sideA.add(buf.readInt());
-    	long decisionNanos = buf.readLong();
+            }
-        long maxDecisionNanos = buf.readLong();
+            for(int i = 0; i < sideBCount; ++i) {
-        boolean turnTimerEnabled = buf.readBoolean();
+                sideB.add(buf.readInt());
-        return new PacketBattleInfo(sideA, sideB, decisionNanos, maxDecisionNanos, turnTimerEnabled);
+            }
+            long decisionNanos = buf.readLong();
+            long maxDecisionNanos = buf.readLong();
+            boolean turnTimerEnabled = buf.readBoolean();
+            return new PacketBattleInfo(sideA, sideB, decisionNanos, maxDecisionNanos, turnTimerEnabled);
+        }
     }
 
-    public static void handle(final PacketBattleInfo pkt, Supplier<NetworkEvent.Context> ctx) {
+    public static class Consumer implements BiConsumer<PacketBattleInfo, CustomPayloadEvent.Context> {
-        ctx.get().enqueueWork(() -> {
+        public Consumer() {}
-            if(TurnBasedMinecraftMod.proxy.getLocalBattle() == null)
+
-            {
+        @Override
-                return;
+        public void accept(PacketBattleInfo pkt, CustomPayloadEvent.Context ctx) {
-            }
+            ctx.enqueueWork(() -> {
-            TurnBasedMinecraftMod.proxy.getLocalBattle().clearCombatants();
+                if(TurnBasedMinecraftMod.proxy.getLocalBattle() == null)
-            for(Integer id : pkt.sideA)
-            {
-                Entity e = Minecraft.getInstance().level.getEntity(id);
-                if(e != null)
                 {
-                    TurnBasedMinecraftMod.proxy.getLocalBattle().addCombatantToSideA(e);
+                    return;
                 }
-            }
+                TurnBasedMinecraftMod.proxy.getLocalBattle().clearCombatants();
-            for(Integer id : pkt.sideB)
+                for(Integer id : pkt.sideA)
-            {
-                Entity e = Minecraft.getInstance().level.getEntity(id);
-                if(e != null)
                 {
-                    TurnBasedMinecraftMod.proxy.getLocalBattle().addCombatantToSideB(e);
+                    Entity e = Minecraft.getInstance().level.getEntity(id);
+                    if(e != null)
+                    {
+                        TurnBasedMinecraftMod.proxy.getLocalBattle().addCombatantToSideA(e);
+                    }
                 }
-            }
+                for(Integer id : pkt.sideB)
-            TurnBasedMinecraftMod.proxy.setBattleGuiTime((int)(pkt.decisionNanos / 1000000000L));
+                {
-            TurnBasedMinecraftMod.proxy.setBattleGuiBattleChanged();
+                    Entity e = Minecraft.getInstance().level.getEntity(id);
-            TurnBasedMinecraftMod.proxy.setBattleGuiTurnTimerEnabled(pkt.turnTimerEnabled);
+                    if(e != null)
-            TurnBasedMinecraftMod.proxy.setBattleGuiTurnTimerMax((int)(pkt.maxDecisionNanos / 1000000000L));
+                    {
-        });
+                        TurnBasedMinecraftMod.proxy.getLocalBattle().addCombatantToSideB(e);
-        ctx.get().setPacketHandled(true);
+                    }
+                }
+                TurnBasedMinecraftMod.proxy.setBattleGuiTime((int)(pkt.decisionNanos / 1000000000L));
+                TurnBasedMinecraftMod.proxy.setBattleGuiBattleChanged();
+                TurnBasedMinecraftMod.proxy.setBattleGuiTurnTimerEnabled(pkt.turnTimerEnabled);
+                TurnBasedMinecraftMod.proxy.setBattleGuiTurnTimerMax((int)(pkt.maxDecisionNanos / 1000000000L));
+            });
+            ctx.setPacketHandled(true);
+        }
     }
 }

src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketBattleMessage.java

@@ -2,7 +2,8 @@ package com.burnedkirby.TurnBasedMinecraft.common.networking;
 
 import java.util.HashMap;
 import java.util.Map;
-import java.util.function.Supplier;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
 
@@ -11,8 +12,8 @@ import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.world.level.Level;
 import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.event.network.CustomPayloadEvent;
 import net.minecraftforge.fml.DistExecutor;
-import net.minecraftforge.network.NetworkEvent;
 
 public class PacketBattleMessage
 {
@@ -39,7 +40,8 @@ public class PacketBattleMessage
         BOW_NO_AMMO(18),
         CREEPER_WAIT(19),
         CREEPER_WAIT_FINAL(20),
-        CREEPER_EXPLODE(21);
+        CREEPER_EXPLODE(21),
+        CROSSBOW_NO_AMMO(22);
         
         private int value;
         private static Map<Integer, MessageType> map = new HashMap<Integer, MessageType>();
@@ -154,30 +156,45 @@ public class PacketBattleMessage
         this.custom = custom;
     }
 
-    public static void encode(PacketBattleMessage pkt, FriendlyByteBuf buf) {
+    public static class Encoder implements BiConsumer<PacketBattleMessage, FriendlyByteBuf> {
-        buf.writeInt(pkt.messageType.getValue());
+        public Encoder() {}
-        buf.writeInt(pkt.entityIDFrom);
+
-        buf.writeInt(pkt.entityIDTo);
+        @Override
-        buf.writeUtf(Utility.serializeDimension(pkt.dimension));
+        public void accept(PacketBattleMessage pkt, FriendlyByteBuf buf) {
-        buf.writeInt(pkt.amount);
+            buf.writeInt(pkt.messageType.getValue());
-        buf.writeUtf(pkt.custom);
+            buf.writeInt(pkt.entityIDFrom);
+            buf.writeInt(pkt.entityIDTo);
+            buf.writeUtf(Utility.serializeDimension(pkt.dimension));
+            buf.writeInt(pkt.amount);
+            buf.writeUtf(pkt.custom);
+        }
     }
 
-    public static PacketBattleMessage decode(FriendlyByteBuf buf) {
+    public static class Decoder implements Function<FriendlyByteBuf, PacketBattleMessage> {
-    	return new PacketBattleMessage(
+        public Decoder() {}
-    		MessageType.valueOf(
+
-    			buf.readInt()),
+        @Override
-			buf.readInt(),
+        public PacketBattleMessage apply(FriendlyByteBuf buf) {
-			buf.readInt(),
+            return new PacketBattleMessage(
-			Utility.deserializeDimension(buf.readUtf()),
+                MessageType.valueOf(
-			buf.readInt(),
+                    buf.readInt()),
-			buf.readUtf());
+                buf.readInt(),
+                buf.readInt(),
+                Utility.deserializeDimension(buf.readUtf()),
+                buf.readInt(),
+                buf.readUtf());
+        }
     }
 
-    public static void handle(final PacketBattleMessage pkt, Supplier<NetworkEvent.Context> ctx) {
+    public static class Consumer implements BiConsumer<PacketBattleMessage, CustomPayloadEvent.Context> {
-        ctx.get().enqueueWork(() -> {
+        public Consumer() {}
-            DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx));
+
-        });
+        @Override
-        ctx.get().setPacketHandled(true);
+        public void accept(PacketBattleMessage pkt, CustomPayloadEvent.Context ctx) {
+            ctx.enqueueWork(() -> {
+                DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx));
+            });
+            ctx.setPacketHandled(true);
+        }
     }
 }

src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketBattleRequestInfo.java

@@ -1,12 +1,13 @@
 package com.burnedkirby.TurnBasedMinecraft.common.networking;
 
-import java.util.function.Supplier;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 import com.burnedkirby.TurnBasedMinecraft.common.Battle;
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
 
 import net.minecraft.network.FriendlyByteBuf;
-import net.minecraftforge.network.NetworkEvent;
+import net.minecraftforge.event.network.CustomPayloadEvent;
 
 public class PacketBattleRequestInfo
 {
@@ -19,22 +20,37 @@ public class PacketBattleRequestInfo
         this.battleID = battleID;
     }
 
-    public static void encode(PacketBattleRequestInfo pkt, FriendlyByteBuf buf) {
+    public static class Encoder implements BiConsumer<PacketBattleRequestInfo, FriendlyByteBuf> {
-    	buf.writeInt(pkt.battleID);
+        public Encoder() {}
+
+        @Override
+        public void accept(PacketBattleRequestInfo pkt, FriendlyByteBuf buf) {
+            buf.writeInt(pkt.battleID);
+        }
     }
 
-    public static PacketBattleRequestInfo decode(FriendlyByteBuf buf) {
+    public static class Decoder implements Function<FriendlyByteBuf, PacketBattleRequestInfo> {
-    	return new PacketBattleRequestInfo(buf.readInt());
+        public Decoder() {}
+
+        @Override
+        public PacketBattleRequestInfo apply(FriendlyByteBuf buf) {
+            return new PacketBattleRequestInfo(buf.readInt());
+        }
     }
 
-    public static void handle(final PacketBattleRequestInfo pkt, Supplier<NetworkEvent.Context> ctx) {
+    public static class Consumer implements BiConsumer<PacketBattleRequestInfo, CustomPayloadEvent.Context> {
-        ctx.get().enqueueWork(() -> {
+        public Consumer() {}
-            Battle b = TurnBasedMinecraftMod.proxy.getBattleManager().getBattleByID(pkt.battleID);
+
-            if(b == null) {
+        @Override
-                return;
+        public void accept(PacketBattleRequestInfo pkt, CustomPayloadEvent.Context ctx) {
-            }
+            ctx.enqueueWork(() -> {
-            TurnBasedMinecraftMod.getHandler().reply(new PacketBattleInfo(b.getSideAIDs(), b.getSideBIDs(), b.getTimerNanos(), TurnBasedMinecraftMod.proxy.getConfig().getDecisionDurationNanos(), !TurnBasedMinecraftMod.proxy.getConfig().isBattleDecisionDurationForever()), ctx.get());
+                Battle b = TurnBasedMinecraftMod.proxy.getBattleManager().getBattleByID(pkt.battleID);
-        });
+                if(b == null) {
-        ctx.get().setPacketHandled(true);
+                    return;
+                }
+                TurnBasedMinecraftMod.getHandler().reply(new PacketBattleInfo(b.getSideAIDs(), b.getSideBIDs(), b.getTimerNanos(), TurnBasedMinecraftMod.proxy.getConfig().getDecisionDurationNanos(), !TurnBasedMinecraftMod.proxy.getConfig().isBattleDecisionDurationForever()), ctx);
+            });
+            ctx.setPacketHandled(true);
+        }
     }
 }

src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketEditingMessage.java

@@ -4,12 +4,13 @@ import com.burnedkirby.TurnBasedMinecraft.common.EntityInfo;
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.event.network.CustomPayloadEvent;
 import net.minecraftforge.fml.DistExecutor;
-import net.minecraftforge.network.NetworkEvent;
 
 import java.util.HashMap;
 import java.util.Map;
-import java.util.function.Supplier;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 public class PacketEditingMessage
 {
@@ -88,58 +89,73 @@ public class PacketEditingMessage
         }
     }
 
-    public static void encode(PacketEditingMessage pkt, FriendlyByteBuf buf) {
+    public static class Encoder implements BiConsumer<PacketEditingMessage, FriendlyByteBuf> {
-    	buf.writeInt(pkt.type.getValue());
+        public Encoder() {}
-    	if(pkt.entityInfo.classType != null) {
+
-    		buf.writeUtf(pkt.entityInfo.classType.getName());
+        @Override
-    	} else {
+        public void accept(PacketEditingMessage pkt, FriendlyByteBuf buf) {
-    		buf.writeUtf("unknown");
+            buf.writeInt(pkt.type.getValue());
-    	}
+            if(pkt.entityInfo.classType != null) {
-    	buf.writeBoolean(pkt.entityInfo.ignoreBattle);
+                buf.writeUtf(pkt.entityInfo.classType.getName());
-    	buf.writeInt(pkt.entityInfo.attackPower);
+            } else {
-    	buf.writeInt(pkt.entityInfo.attackProbability);
+                buf.writeUtf("unknown");
-    	buf.writeInt(pkt.entityInfo.attackVariance);
+            }
-    	buf.writeUtf(pkt.entityInfo.attackEffect.toString());
+            buf.writeBoolean(pkt.entityInfo.ignoreBattle);
-    	buf.writeInt(pkt.entityInfo.attackEffectProbability);
+            buf.writeInt(pkt.entityInfo.attackPower);
-    	buf.writeInt(pkt.entityInfo.defenseDamage);
+            buf.writeInt(pkt.entityInfo.attackProbability);
-    	buf.writeInt(pkt.entityInfo.defenseDamageProbability);
+            buf.writeInt(pkt.entityInfo.attackVariance);
-    	buf.writeInt(pkt.entityInfo.evasion);
+            buf.writeUtf(pkt.entityInfo.attackEffect.toString());
-    	buf.writeInt(pkt.entityInfo.speed);
+            buf.writeInt(pkt.entityInfo.attackEffectProbability);
-    	buf.writeUtf(pkt.entityInfo.category);
+            buf.writeInt(pkt.entityInfo.defenseDamage);
-    	buf.writeInt(pkt.entityInfo.decisionAttack);
+            buf.writeInt(pkt.entityInfo.defenseDamageProbability);
-    	buf.writeInt(pkt.entityInfo.decisionDefend);
+            buf.writeInt(pkt.entityInfo.evasion);
-    	buf.writeInt(pkt.entityInfo.decisionFlee);
+            buf.writeInt(pkt.entityInfo.speed);
-    	buf.writeUtf(pkt.entityInfo.customName);
+            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 static PacketEditingMessage decode(FriendlyByteBuf buf) {
+    public static class Decoder implements Function<FriendlyByteBuf, PacketEditingMessage> {
-    	Type type = Type.valueOf(buf.readInt());
+        public Decoder() {}
-    	EntityInfo einfo = new EntityInfo();
+
-    	try {
+        @Override
-    		einfo.classType = einfo.getClass().getClassLoader().loadClass(buf.readUtf());
+        public PacketEditingMessage apply(FriendlyByteBuf buf) {
-    	} catch (ClassNotFoundException e) { /* ignored */ }
+            Type type = Type.valueOf(buf.readInt());
-        einfo.ignoreBattle = buf.readBoolean();
+            EntityInfo einfo = new EntityInfo();
-        einfo.attackPower = buf.readInt();
+            try {
-        einfo.attackProbability = buf.readInt();
+                einfo.classType = einfo.getClass().getClassLoader().loadClass(buf.readUtf());
-        einfo.attackVariance = buf.readInt();
+            } catch (ClassNotFoundException e) { /* ignored */ }
-        einfo.attackEffect = EntityInfo.Effect.fromString(buf.readUtf());
+            einfo.ignoreBattle = buf.readBoolean();
-        einfo.attackEffectProbability = buf.readInt();
+            einfo.attackPower = buf.readInt();
-        einfo.defenseDamage = buf.readInt();
+            einfo.attackProbability = buf.readInt();
-        einfo.defenseDamageProbability = buf.readInt();
+            einfo.attackVariance = buf.readInt();
-        einfo.evasion = buf.readInt();
+            einfo.attackEffect = EntityInfo.Effect.fromString(buf.readUtf());
-        einfo.speed = buf.readInt();
+            einfo.attackEffectProbability = buf.readInt();
-        einfo.category = buf.readUtf();
+            einfo.defenseDamage = buf.readInt();
-        einfo.decisionAttack = buf.readInt();
+            einfo.defenseDamageProbability = buf.readInt();
-        einfo.decisionDefend = buf.readInt();
+            einfo.evasion = buf.readInt();
-        einfo.decisionFlee = buf.readInt();
+            einfo.speed = buf.readInt();
-        einfo.customName = buf.readUtf();
+            einfo.category = buf.readUtf();
-    	return new PacketEditingMessage(type, einfo);
+            einfo.decisionAttack = buf.readInt();
+            einfo.decisionDefend = buf.readInt();
+            einfo.decisionFlee = buf.readInt();
+            einfo.customName = buf.readUtf();
+            return new PacketEditingMessage(type, einfo);
+        }
     }
 
-    public static void handle(final PacketEditingMessage pkt, Supplier<NetworkEvent.Context> ctx) {
+    public static class Consumer implements BiConsumer<PacketEditingMessage, CustomPayloadEvent.Context> {
-        ctx.get().enqueueWork(() -> {
+        public Consumer() {}
-            DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx));
+
-        });
+        @Override
-        ctx.get().setPacketHandled(true);
+        public void accept(PacketEditingMessage pkt, CustomPayloadEvent.Context ctx) {
+            ctx.enqueueWork(() -> {
+                DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx));
+            });
+            ctx.setPacketHandled(true);
+        }
     }
 }

src/main/java/com/burnedkirby/TurnBasedMinecraft/common/networking/PacketGeneralMessage.java

@@ -1,13 +1,14 @@
 package com.burnedkirby.TurnBasedMinecraft.common.networking;
 
-import java.util.function.Supplier;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 import com.burnedkirby.TurnBasedMinecraft.common.TurnBasedMinecraftMod;
 
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.event.network.CustomPayloadEvent;
 import net.minecraftforge.fml.DistExecutor;
-import net.minecraftforge.network.NetworkEvent;
 
 public class PacketGeneralMessage
 {
@@ -27,18 +28,33 @@ public class PacketGeneralMessage
         this.message = message;
     }
 
-    public static void encode(PacketGeneralMessage pkt, FriendlyByteBuf buf) {
+    public static class Encoder implements BiConsumer<PacketGeneralMessage, FriendlyByteBuf> {
-    	buf.writeUtf(pkt.message);
+        public Encoder() {}
+
+        @Override
+        public void accept(PacketGeneralMessage pkt, FriendlyByteBuf buf) {
+            buf.writeUtf(pkt.message);
+        }
     }
 
-    public static PacketGeneralMessage decode(FriendlyByteBuf buf) {
+    public static class Decoder implements Function<FriendlyByteBuf, PacketGeneralMessage> {
-    	return new PacketGeneralMessage(buf.readUtf());
+        public Decoder() {}
+
+        @Override
+        public PacketGeneralMessage apply(FriendlyByteBuf buf) {
+            return new PacketGeneralMessage(buf.readUtf());
+        }
     }
 
-    public static void handle(final PacketGeneralMessage pkt, Supplier<NetworkEvent.Context> ctx) {
+    public static class Consumer implements BiConsumer<PacketGeneralMessage, CustomPayloadEvent.Context> {
-        ctx.get().enqueueWork(() -> {
+        public Consumer() {}
-            DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx));
+
-        });
+        @Override
-        ctx.get().setPacketHandled(true);
+        public void accept(PacketGeneralMessage pkt, CustomPayloadEvent.Context ctx) {
+            ctx.enqueueWork(() -> {
+                DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> TurnBasedMinecraftMod.proxy.handlePacket(pkt, ctx));
+            });
+            ctx.setPacketHandled(true);
+        }
     }
 }

src/main/resources/META-INF/mods.toml

@@ -32,6 +32,9 @@ authors="${mod_authors}" #optional
 description='''
 Implements turn-based-battle in Minecraft.
 '''
+
+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

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.23.1",
-  "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": []
-}
-]