Battle ends if teleport succeeds. Don't broadcast messages for ended battles

Signed-off-by: Polymeta <40173118+Polymeta@users.noreply.github.com>

.gitattributes

@@ -3,3 +3,4 @@
 # are changed when only line endings change.
 src/generated/**/.cache/cache text eol=lf
 src/generated/**/*.json text eol=lf
+CHANGELOG.md merge=union

.gitignore

@@ -21,6 +21,8 @@ build
 # other
 eclipse
 run
+runClient
+runServer
 
 # Files from Forge MDK
 forge*changelog.txt
@@ -33,3 +35,9 @@ common/src/main/resources/assets/cobblemon/showdown
 # Generated files
 */generated/resources/*
 /fabric/src/generated/resources/cobblemon-common.accesswidener
+/.ignored/
+common/.fabric
+.kotlin/
+
+# MacOS
+.DS_Store

.gitlab-ci.yml

@@ -1,64 +1,185 @@
+image: amazoncorretto:21
+
 before_script:
   - export GRADLE_USER_HOME=`pwd`/.gradle
 
+# TODO add client reference test process, search for import com.cobblemon.mod.common.client
+
 stages:
+  - preprocessing
+  - packsquash
+  - replaceresources
   - build
   - deploy
 
-#TODO add client reference test process, search for import com.cobblemon.mod.common.client
+check_assets_cache:
+  stage: preprocessing
+  script:
+    - echo "Checking if cached hash matches current hash"
+
+    # Calculate the current hash
+    - find common/src/main/resources/assets common/src/main/resources/data -type f -exec sha256sum {} + | sort -k 2 | sha256sum > current_hash.txt
+    - echo "Current hash:"
+    - cat current_hash.txt
+
+    # Check for the existence of the previous hash
+    - if [[ -f assets_data_hash.txt ]]; then
+      echo "Previous cached hash found:";
+      cat assets_data_hash.txt;
+      if cmp -s assets_data_hash.txt current_hash.txt; then
+      echo "Hashes match, skipping PackSquash";
+      rm -f run_packsquash.flag || true;
+      else
+      echo "Hashes differ, PackSquash needed";
+      touch run_packsquash.flag;
+      fi;
+      else
+      echo "No cached hash found, marking PackSquash as required";
+      touch run_packsquash.flag;
+      fi
+
+    # Save the current hash for future runs
+    - echo "Saving current hash to cache";
+    - cp current_hash.txt assets_data_hash.txt
+  artifacts:
+    paths:
+      - current_hash.txt
+      - assets_data_hash.txt
+      - run_packsquash.flag
+    expire_in: 7 days
+  cache:
+    key: "cache-${CI_COMMIT_REF_NAME}"
+    paths:
+      - assets_data_hash.txt
+      - ./compressed_pack.zip
+
+setup_resource_pack:
+  stage: preprocessing
+  script:
+    - echo "Setting up fake resource pack"
+    - mkdir ./fake_resource_pack
+    - cp -r common/src/main/resources/assets common/src/main/resources/data ./fake_resource_pack/
+    - echo '{"pack":{"pack_format":34,"description":"Fake Cobblemon Pack"}}' > ./fake_resource_pack/pack.mcmeta
+  artifacts:
+    paths:
+      - ./fake_resource_pack/
+    expire_in: 7 days
+
+setup_packsquash:
+  stage: preprocessing
+  script:
+    - echo "Installing wget & unzip"
+    - yum install -y wget unzip
+    - echo "Downloading PackSquash"
+    - wget https://github.com/ComunidadAylas/PackSquash/releases/download/v0.4.0/PackSquash.CLI.executable.x86_64-unknown-linux-musl.zip
+    - unzip PackSquash.CLI.executable.x86_64-unknown-linux-musl.zip -d ./packsquash_bin
+    - echo "Creating PackSquash options.toml"
+    - |
+      cat <<EOF > ./options.toml
+      pack_directory = "./fake_resource_pack/"
+      output_file_path = "./compressed_pack.zip"
+      zip_spec_conformance_level = "high"
+      ['**/*?.ogg']
+      transcode_ogg = false
+      two_pass_vorbis_optimization_and_validation = false
+      sampling_frequency = 999999
+      empty_audio_optimization=false
+      EOF
+  artifacts:
+    paths:
+      - ./packsquash_bin/
+      - ./options.toml
+    expire_in: 7 days
+
+default:
+  artifacts:
+    expire_in: 7 days
+
+run_packsquash:
+  stage: packsquash
+  dependencies:
+    - check_assets_cache
+    - setup_resource_pack
+    - setup_packsquash
+  script:
+    - ls -l
+    - if [[ ! -f ./compressed_pack.zip || -f run_packsquash.flag ]]; then
+      echo "Running PackSquash";
+      chmod +x ./packsquash_bin/packsquash;
+      ./packsquash_bin/packsquash ./options.toml;
+      else
+      echo "Skipping PackSquash; no changes detected and compressed pack exists";
+      fi
+  cache:
+    key: "cache-${CI_COMMIT_REF_NAME}"
+    policy: pull-push
+    paths:
+      - assets_data_hash.txt
+      - ./compressed_pack.zip
+  artifacts:
+    paths:
+      - ./compressed_pack.zip
+
+replace_resources:
+  stage: replaceresources
+  dependencies:
+    - run_packsquash
+  script:
+    - echo "Installing unzip"
+    - yum install -y unzip
+
+    - echo "Unzipping compressed pack"
+    - mkdir temp_unpack
+    - unzip ./compressed_pack.zip -d temp_unpack
+
+    - echo "Removing original assets and data"
+    - rm -rf common/src/main/resources/assets
+    - rm -rf common/src/main/resources/data
+
+    - echo "Replacing assets and data"
+    - mv temp_unpack/assets common/src/main/resources/
+    - mv temp_unpack/data common/src/main/resources/
+  artifacts:
+    paths:
+      - common/src/main/resources/
 
 build:
   stage: build
-  only:
-    - branches@cable-mc/cobblemon
+  dependencies:
+    - replace_resources
   script:
     - export GRADLE_OPTS="-Xmx4G -Xms4G"
     - chmod +x ./gradlew
     - ./gradlew build
-  cache:
-    key: "$CI_COMMIT_REF_NAME"
-    policy: push
+  artifacts:
     paths:
-      - forge/build/libs
+      - neoforge/build/libs
       - fabric/build/libs
 
 publish:
   stage: deploy
   dependencies:
     - build
-  cache:
-    key: "CI_COMMIT_REF_NAME"
-    policy: pull
-    paths:
-      - forge/build/libs/*.jar
-      - fabric/build/libs/*.jar
   rules:
-    - if: '$CI_COMMIT_BRANCH == "main"'
+    - if: '$CI_PROJECT_PATH == "cable-mc/cobblemon" && $CI_COMMIT_BRANCH == "main"'
   script:
     - export GRADLE_OPTS="-Xmx4G -Xms4G"
     - chmod +x ./gradlew
     - ./gradlew publish
+  artifacts:
+    paths:
+      - neoforge/build/libs/*.jar
+      - fabric/build/libs/*.jar
 
-# Separate step to deploy the artifacts, save Norry the headache of keeping even more shit around
-deploy:
+deploy_artifacts:
   stage: deploy
   dependencies:
     - build
-  when: manual
-  cache:
-    key: "$CI_COMMIT_REF_NAME"
-    policy: pull
-    paths:
-      - forge/build/libs/*.jar
-      - fabric/build/libs/*.jar
-  script: 
+  script:
     - echo "Collecting artifacts..."
-    - mv forge/build/libs/*+*.jar ./
-    - mv fabric/build/libs/*+*.jar ./
+    - find neoforge/build/libs/ -type f -name "*.jar" | grep -vE "dev-shadow|sources|javadoc" | xargs -I {} mv {} ./
+    - find fabric/build/libs/ -type f -name "*.jar" | grep -vE "dev-shadow|sources|javadoc" | xargs -I {} mv {} ./
     - for f in *.jar; do mv "$f" "$(echo "$f" | sed s/+/b$CI_PIPELINE_IID+/)"; done
   artifacts:
-    expire_in: 28 days
     paths:
       - ./*.jar
-#      - forge/build/libs/*+*.jar
-#      - fabric/build/libs/*+*.jar

.gitlab/issue_templates/Default.md

@@ -0,0 +1,30 @@
+<!-- 1. START HERE: (Before filling all this out, please quickly go to the list of all issues: (https://gitlab.com/cable-mc/cobblemon/-/issues/?sort=created_date&state=all) and do a quick search to see if your issue has already been reported. If it has, please add a comment to the existing issue instead of creating a new one.)-->
+<!-- 2. If the issue was not already reported, please fill out the following template. -->
+<!-- 3. If you do not know something, don't worry! Just fill out as much as you can to make sure the issue can get fixed asap. -->
+
+## Summary
+(Please summarize the bug encountered concisely)
+
+## Steps to reproduce
+(How one can reproduce the issue - this is very important)
+
+## What is the current bug behavior?
+(What actually happens)
+
+## What is the expected correct behavior?
+(What you should see instead)
+
+## Cobblemon Version and Mod Loader
+(Are you using Forge or Fabric? And what version of Cobblemon are you using?)
+
+## Mods used besides Cobblemon
+(Did you have any other mods installed besides Cobblemon? If so, please list them here)
+
+## Relevant logs, screenshots and/or videos
+(Paste any relevant logs - use code blocks (```) at the start and end to format console output, logs, and code, as
+it's very hard to read otherwise. Or just put a link here)
+
+## Additional Information
+(If you can, link to the line of code that might be responsible for the problem, or any other info that might be useful)
+
+/label ~bug

.gitlab/issue_templates/Feature Request.md

@@ -0,0 +1,31 @@
+<!-- 1. START HERE: (Before filling all this out, please quickly go to the list of all issues: (https://gitlab.com/cable-mc/cobblemon/-/issues/?sort=created_date&state=all) and do a quick search to see if your feature was already requested. If it is, please add a comment to the existing issue instead of creating a new one.)-->
+<!-- 2. If the feature request was not already reported, please fill out the following template. -->
+<!-- 3. If you do not know something, don't worry! Just fill out as much as you can. -->
+<!-- 4. The more info you provide here, the greater the chance of it being considered by the Design team. -->
+
+## Summary
+(Please summarize your feature request concisely)
+
+## What are the projected benefits of this feature?
+- (List)
+- (benefits)
+- (here)
+
+## What could speak against this feature?
+- (List)
+- (possible)
+- (cons)
+
+## Why do you think the benefits outweigh the cons?
+(Explain why you think the benefits outweigh the cons)
+
+## Mods involved besides Cobblemon
+(Does your suggestion require any other mods besides Cobblemon? If so, please list them here)
+
+## Sketches, screenshots and/or videos
+(Feel free to add any sketches, screenshots or videos that might help the Design team understand your suggestion)
+
+## Additional Information
+(Is there anything else you would like to add?)
+
+/label ~feature ~suggestion ~needs-design

CHANGELOG-AI.md

@@ -0,0 +1,26 @@
+### Additions
+- Rebuilt Pokémon AI to use Minecraft's Brain system, allowing for more complex behaviours and interactions.
+  - As an early pass of this, pastured Pokémon will now sleep when appropriate, and may come up to you when they see you.
+  - Probably also added a whole bunch of bugs.
+  - Dog Pokémon (Growlithe, Arcanine, etc.) intimidate Skeletons.
+  - Cat Pokémon (Meowth, Persian, etc.) intimidate Creepers and Phantoms.
+  - Sleep-related Pokémon (Munsharna, Komala, etc.) intimidate Phantoms.
+  - Some Pokémon naturally hunt each other.
+  - Some Pokémon herd together.
+- Added a Behaviour Editor to the NPC editing screen.
+- Added /behaviouredit command for opening the Behaviour Editor on Pokémon and NPCs.
+  - Editing variables for Pokémon is not yet supported.
+
+### Developer
+- baseScale in NPCs has been removed from classes and presets, and in the entity it is replaced with hitboxScale and renderScale.
+- Added `EntityCallbacks` to `NPCEntity` and `PokemonEntity`. You can trigger custom callback types by using `[Entity].callbacks.process(...)`
+
+### Fixes
+- Fixed Pokémon with a moving walk target frequently spinning in place as they re-calculate their path.
+
+### MoLang & Datapacks
+- Added a `behaviours` datapack folder which motivates the Behaviour Editor screen on NPCs and Pokémon.
+- Added "callback" support on PokemonEntity and NPCEntity that allows MoLang scripts to be executed in response to certain scenarios.
+- Added very many behaviours to choose from.
+- Removed many NPC presets that now exist as behaviours. This is a breaking change if you are using NPCs with these presets. 
+  - NPCs with these presets should be modified to instead list under `"behaviours"` all the equivalent behaviours.

CHANGELOG-COOKING.md

@@ -0,0 +1,35 @@
+### Additions
+- Added the Campfire Pot, made from apricorns and placed onto campfires.
+  - This pot can be used to make bait for fishing, Poké Cakes, Lure Cakes, local specialties, and potions (less efficiently than a brewing stand).
+  - There is a different pot for each apricorn colour because at this point I think we may have an addiction.
+- Added Aprijuice, made from the Campfire Pot using apricorns with seasoning to give flavours.
+  - Aprijuice can be fed to ride-able Pokémon to improve their riding characteristics, depending on the flavour and the Pokémon's nature.
+- Added Lure Cakes, made from the Campfire Pot using honey and berries.
+  - Lure Cakes can be used to modify the spawn rate of Pokémon in the wild.
+- Added the Saccharine Tree, which can be found in the wild and is used to obtain Honey Bottles.
+  - The leaves of the tree can be harvested to obtain honey, which can be used in the Campfire Pot to make Lure Cakes.
+  - The Log of the tree can be interacted with using a honey bottle to create a Honey-Slathered Saccharine Log, which increases the change of spawning a Pokémon with a Hidden Ability.
+- Added Hearty Grains
+- Clicking on the Progress Arrow will show the JEI Recipe Book for the Campfire Pot, which will show all recipes that can be made with it.
+- Added a Ton of Redstone Compatibility.
+   - Dispenser can now Honey and Unhoney:
+      - Saccharine Log
+      - Saccharine Leaves
+   - Redstone can Close and Open the Lid of a Cooking Pot
+      - Powered = Closed
+      - Unpowered = Open
+   - Hoppers can be used to insert items into a Cooking pot
+      - Top = Seasonals
+      - All Sides = Crafting
+      - Bottom = Extract the Result
+   - Observer will recognise when a Cooking pot is Closed or Opened
+   - Comparator Calculates a Signal Strength depending on the items inside the cooking pot
+   - Sculk Sensor
+       - Saccharine Leaves
+       - Opening and Closing the Cooking Pot
+       - Saccharine Log
+
+### Datapack and Addon Changes
+- Renamed the fishing_baits datapack folder to spawn_bait_effects.
+- Added `seasonings` datapack folder for controlling usable items in the campfire pot and what colour and flavour they apply.
+- Added campfire pot recipe type, which you could use to make anything work as fishing bait.

CHANGELOG-MARKS.md

@@ -0,0 +1,13 @@
+### Additions
+- Added functionality for marks.
+- Added data for all marks and ribbons from the mainline Pokémon games.
+- Implemented fishing, personality, weather, and time related marks, that can rarely be granted to a wild-spawned Pokémon.
+- Added marks screen within the summary UI.
+- Added `/givemark <player> <partySlot> <mark>` command to give a mark to a Pokémon.
+- Added `/takemark <player> <partySlot> <mark>` command to remove a mark from a Pokémon.
+- Added `/giveallmarks <player> <partySlot>` command to give all available marks to a Pokémon.
+
+### MoLang & Datapacks
+- Added Flows for `bobber_spawn_pokemon_post`, `pokemon_entity_spawn`, and `fossil_revived`.
+- Added `marks` datapack folder.
+- Added MoLang functions `entity.is_in_rain`, `pokemon.add_marks(Mark...)`, `pokemon.add_potential_marks(Mark...)`, `pokemon.add_marks_with_chance(Mark...)`, `pokemon.apply_potential_marks`, and `world.is_snowing_at(x, y, z)`.

CHANGELOG-PC.md

@@ -0,0 +1,38 @@
+### Additions
+- Added ability to rename PC Boxes by clicking on the name of a box.
+- Added box options buttons for boxes, toggleable by clicking the right icon button in the bottom bar.
+  - The option buttons on the left side allow for sorting the box by name, level, Pokédex number, gender, and type. Shift clicking allows for sorting in reverse order.
+  - The button on the right allows for changing the box wallpaper.
+  - 10 additional color-based wallpapers have been added.
+    - 5 unlockable biome-based wallpapers have been added, which can be unlocked by visiting:
+      - Forest biome
+      - Ocean biome
+      - Cave Biome
+      - The End
+      - The Nether
+- Added filter functionality in PC UI, which supports `PokemonProperties` (e.g. `shiny=yes` shows all shiny Pokémon).
+  - Names can be filtered by exact or partial matches, e.g. entering "cha" will show Charmander, Charmeleon, etc.
+- Added `/changewallpaper <player> <boxNumber> <wallpaper>` command to change a box wallpaper through commands.
+- Added `/renamebox <player> <boxNumber> <name>` command to rename a PC box through commands.
+- Added IVs and EVs stat displays in PC.
+  - The displays can be cycled through by scrolling when the display is hovered over.
+- Added ability to cycle through boxes by scrolling when the box is hovered over.
+- PC will now open to last box viewed within a session.
+
+### Changes
+- Slots in pastures will now have darker backgrounds and italicised Pokémon names if the Pokémon is not owned by the player.
+- The pasture slot will show the name of the Pokémon owner when hovered if the Pokémon is not owned.
+- Increased the default PC box count from 30 to 40 to accommodate the fact that we have way more Pokémon now. If you've changed this config option then you'll need to edit it again after starting up with 1.7!
+
+### Developer
+- Added `RenamePCBoxEvent.Pre` and `RenamePCBoxEvent.Post` events to prevent players from renaming a box or changing their input.
+- Added `ChangePCBoxWallpaperEvent.Pre` and `ChangePCBoxWallpaperEvent.Post` to prevent players from changing wallpapers or changing their selection.
+- Added `WallpaperCollectionEvent` which gets called when clients connect to a server, allowing the server to handle which of the client-found wallpapers it's allowed to move (collected wallpapers can be removed for example to make it "vanish" client-side).
+- Added `WallpaperUnlockedEvent`.
+- Renamed `SetPCBoxPokemonPacket` and the respective handler to `SetPCBoxPacket`.
+
+### Addons
+- Added Flows for `player_tick_pre`, `player_tick_post`, `advancement_earned`, `right_clicked_entity`, `right_clicked_block`, `player_died`, `wallpaper_unlocked`.
+- Flows now have `q.` for any context properties in addition to the `c.` properties, making it a bit more convenient when calling other scripts from Flows.
+- Added `unlockable_pc_box_wallpapers` datapack folder for wallpapers that need to be unlocked before they're usable.
+- Wallpapers are loaded from `assets/<namespace>/textures/gui/pc/wallpaper/` and all wallpapers in this folder are available to the client to choose by default.

CHANGELOG-RIDING.md

@@ -0,0 +1,4 @@
+### Additions
+
+- Added the ability to ride Pokémon by shift-right clicking and selecting the ride option.
+- Added /calculateseatpositions command for approximating hitbox locations for riding configurations.

CHANGELOG-SHARED-MODEL-REPO.md

@@ -0,0 +1,10 @@
+
+### Additions
+- Added support for NPCs to use Pokémon models and vice versa. This will require changes in addons that add fossil types due to naming conflicts between fossils and the Pokémon species.
+- Added `/changejointscale` command to change the scale of a joint in a model. Unbelievably funny.
+
+### Developer
+- Removed all VaryingModelRepository subclasses into the parent class. 
+
+### Addons
+- Added `transformedParts` to the root of poser JSONs so it now exists in both poses and the model overall. 

CHANGELOG-SPAWNING.md

@@ -0,0 +1,17 @@
+
+### Additions
+- Pokémon can now spawn in herds, either as distinct herd groupings or simply several Pokémon spawning at once.
+
+### Fixes
+- Fixed the "enabled" property in spawn files not actually being respected. Where do they find these devs?
+- Fixed Terralith's shrubland not counting as plains for spawning purposes the way it was intended to.
+
+### Developer
+- Spawning Influences now have the context of what the other buckets are when adjusting bucket weights. This will break existing influences that do bucket weight adjustment.
+- Renamed heaps of things in the spawning system to make more sense.
+  - SpawningContext is now SpawnablePosition
+  - WorldSlice is SpawningZone
+  - SpawningProspector is now SpawningZoneGenerator
+- Renamed things in Spawn Rules to go with the other renames:
+  - contextSelector is now spawnablePositionSelector
+  - context is now spawnable_position

README.md

@@ -1,6 +1,6 @@
 # Cobblemon
 
-An open-source Pokémon mod for Minecraft Java Edition, written in Kotlin for Fabric and Forge.
+An open-source Pokémon mod for Minecraft Java Edition, written in Kotlin for Fabric and NeoForge.
 
 ## Getting started
 

ai_bugs.txt

@@ -0,0 +1,9 @@
+
+- Nodemaker bug, it thinks jumps are possible from water up an entire block - they aint
+   https://gyazo.com/759b8285e7c07046ff2e54adf0d7a7ac
+
+- Why is magikarp trying to path through ice
+  https://gyazo.com/ae230758c529f885eeb0dd91e60530d2
+
+- We should use mixins to put the path node filtering from OmniPathNodeMaker in the base classes otherwise
+  NPC wandering will be jank too.

archive/archived-assets/README.md

@@ -0,0 +1 @@
+These are assets that may be used in the future, but can't be put in tFheir respective folders at the moment for some reason or another

build-logic/build.gradle.kts

@@ -1,18 +0,0 @@
-plugins {
-    `kotlin-dsl`
-}
-
-repositories {
-    gradlePluginPortal()
-    maven("https://maven.architectury.dev/")
-    maven("https://maven.fabricmc.net/")
-    maven("https://maven.minecraftforge.net/")
-}
-
-dependencies {
-    implementation(libs.kotlin)
-    implementation(libs.licenser)
-    implementation(libs.shadow)
-    implementation(libs.loom)
-    implementation(libs.architecturyPlugin)
-}

build-logic/settings.gradle.kts

@@ -1,10 +0,0 @@
-import ca.stellardrift.build.configurate.ConfigFormats
-import ca.stellardrift.build.configurate.catalog.PolyglotVersionCatalogExtension
-
-plugins {
-    id("ca.stellardrift.polyglot-version-catalogs") version "5.0.1"
-}
-
-extensions.configure<PolyglotVersionCatalogExtension> {
-    from(ConfigFormats.YAML, file("../gradle/libs.versions.yml"))
-}

build-logic/src/main/kotlin/cobblemon.base-conventions.gradle.kts

@@ -1,71 +0,0 @@
-/*
- *
- *  * Copyright (C) 2023 Cobblemon Contributors
- *  *
- *  * This Source Code Form is subject to the terms of the Mozilla Public
- *  * License, v. 2.0. If a copy of the MPL was not distributed with this
- *  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- *
- */
-
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
-val accessWidenerFile = "src/main/resources/cobblemon-common.accesswidener"
-
-plugins {
-    java
-    `java-library`
-    id("org.cadixdev.licenser")
-    id("dev.architectury.loom")
-    id("architectury-plugin")
-    kotlin("jvm")
-}
-
-repositories {
-    mavenCentral()
-    //JEI
-    maven("https://maven.blamejared.com/")
-    maven("https://maven.tterrag.com/")
-}
-
-license {
-    header(rootProject.file("HEADER"))
-}
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_17
-    targetCompatibility = JavaVersion.VERSION_17
-}
-
-architectury {
-    minecraft = project.property("mc_version").toString()
-}
-
-loom {
-    silentMojangMappingsLicense()
-    accessWidenerPath.set(project(":common").file(ACCESS_WIDENER))
-
-    mixin {
-        defaultRefmapName.set("cobblemon-${project.name}-refmap.json")
-    }
-}
-
-dependencies {
-    minecraft("net.minecraft:minecraft:${rootProject.property("mc_version")}")
-    mappings("net.fabricmc:yarn:${rootProject.property("yarn_version")}:v2")
-}
-
-tasks {
-    withType<JavaCompile> {
-        options.encoding = "UTF-8"
-        options.release.set(17)
-    }
-
-    withType<KotlinCompile> {
-        kotlinOptions.jvmTarget = "17"
-    }
-
-    withType<Jar> {
-        from(rootProject.file("LICENSE"))
-    }
-}

build-logic/src/main/kotlin/cobblemon.platform-conventions.gradle.kts

@@ -1,32 +0,0 @@
-plugins {
-    id("cobblemon.base-conventions")
-    id("com.github.johnrengelman.shadow")
-}
-
-val bundle: Configuration by configurations.creating {
-    isCanBeConsumed = false
-    isCanBeResolved = true
-}
-
-tasks {
-
-    jar {
-        archiveBaseName.set("Cobblemon-${project.name}")
-        archiveClassifier.set("dev-slim")
-    }
-
-    shadowJar {
-        archiveClassifier.set("dev-shadow")
-        archiveBaseName.set("Cobblemon-${project.name}")
-        configurations = listOf(bundle)
-        mergeServiceFiles()
-    }
-
-    remapJar {
-        dependsOn(shadowJar)
-        inputFile.set(shadowJar.flatMap { it.archiveFile })
-        archiveBaseName.set("Cobblemon-${project.name}")
-        archiveVersion.set("${rootProject.version}")
-    }
-
-}

build-logic/src/main/kotlin/cobblemon.publish-conventions.gradle.kts

@@ -1,37 +0,0 @@
-plugins {
-    java
-    `java-library`
-    id("maven-publish")
-    id("dev.architectury.loom")
-}
-
-java {
-    withSourcesJar()
-    withJavadocJar()
-}
-
-publishing {
-    repositories {
-        maven("https://maven.impactdev.net/repository/development/") {
-            name = "ImpactDev-Public"
-            credentials {
-                username = System.getenv("COBBLEMON_MAVEN_USER")
-                password = System.getenv("COBBLEMON_MAVEN_PASSWORD")
-            }
-        }
-    }
-
-    publications {
-        create<MavenPublication>(project.name) {
-            artifact(tasks.remapJar)
-            artifact(tasks.remapSourcesJar)
-
-            @Suppress("UnstableApiUsage")
-            loom.disableDeprecatedPomGeneration(this)
-
-            groupId = "com.cobblemon"
-            artifactId = project.findProperty("maven.artifactId")?.toString() ?: project.name
-            version = rootProject.version.toString()
-        }
-    }
-}

build-logic/src/main/kotlin/cobblemon.root-conventions.gradle.kts

@@ -1,21 +0,0 @@
-plugins {
-    `java-library`
-}
-
-tasks {
-    val collectJars by registering(Copy::class) {
-        val tasks = subprojects.filter { it.path != ":common" }.map { it.tasks.named("remapJar") }
-        dependsOn(tasks)
-
-        from(tasks)
-        into(buildDir.resolve("libs"))
-    }
-
-    assemble {
-        dependsOn(collectJars)
-    }
-}
-
-tasks.withType<Test> {
-    useJUnitPlatform()
-}

build.gradle.kts

@@ -1,12 +1,11 @@
 plugins {
-    base
     id("cobblemon.root-conventions")
 }
 
-group = "com.cobblemon.mod"
 version = "${project.property("mod_version")}+${project.property("mc_version")}"
 
-val isSnapshot = project.property("snapshot")?.equals("true") ?: false
+val isSnapshot = project.property("snapshot")?.equals("true") == true
 if (isSnapshot) {
-    version = "$version-SNAPSHOT"
-}
+    val fixedBranchName = versioning.info.branch.substringAfter("/")
+    version = "$version-${fixedBranchName}-${versioning.info.build}"
+}

common/build.gradle.kts

@@ -1,3 +1,10 @@
+
+import utilities.isSnapshot
+import utilities.version
+import java.time.OffsetDateTime
+import java.time.ZoneOffset
+import java.time.format.DateTimeFormatter
+
 /*
  *
  *  * Copyright (C) 2023 Cobblemon Contributors
@@ -11,44 +18,50 @@
 plugins {
     id("cobblemon.base-conventions")
     id("cobblemon.publish-conventions")
+
+    id("net.kyori.blossom")
+    id("org.jetbrains.gradle.plugin.idea-ext")
 }
 
 architectury {
-    common("forge", "fabric")
+    common("neoforge", "fabric")
 }
 
 repositories {
     maven(url = "${rootProject.projectDir}/deps")
     maven(url = "https://api.modrinth.com/maven")
+    maven(url = "https://maven.neoforged.net/releases")
+    maven(url = "https://maven.gegy.dev")
     mavenLocal()
 }
 
 dependencies {
-    implementation(libs.stdlib)
-    implementation(libs.reflect)
-
-    modImplementation(libs.fabricLoader)
-    //Flywheel has no common dep so just pick one and don't use any platform specific code in common
-//    modCompileOnly(libs.flywheelFabric)
+    implementation(libs.bundles.kotlin)
+    modImplementation(libs.fabric.loader)
     modApi(libs.molang)
-    compileOnlyApi(libs.jeiApi)
-    modCompileOnly(libs.adornFabric)
 
-    // For Showdown
+    // Integrations
+    compileOnlyApi(libs.jei.api)
+    modCompileOnly(libs.bundles.common.integrations.compileOnly) {
+        isTransitive = false
+    }
+    // LambDynamicLights is handled differently because we need the Mojang-mappings version of it.
+    modCompileOnly(libs.lambDynamicLights) {
+        capabilities {
+            requireCapability("dev.lambdaurora.lambdynamiclights:api-mojmap")
+        }
+    }
+    // Flywheel has no common dep so just pick one and don't use any platform specific code in common
+    // modCompileOnly(libs.flywheelFabric)
+
+    // Showdown
     modCompileOnly(libs.graal)
 
-    //shadowCommon group: 'commons-io', name: 'commons-io', version: '2.6'
+    // Data Storage
+    modCompileOnly(libs.bundles.mongo)
 
-    // For datastore
-    modCompileOnly(libs.mongoDriverCore)
-    modCompileOnly(libs.mongoDriverSync)
-
-    testRuntimeOnly(libs.junitEngine)
-    testImplementation(libs.junitApi)
-    testImplementation(libs.junitParams)
-    testImplementation(libs.mockito)
-    testImplementation(libs.mockk)
-    testImplementation(libs.classgraph)
+    // Unit Testing
+    testImplementation(libs.bundles.unitTesting)
 }
 
 tasks.withType<Test> {
@@ -58,3 +71,34 @@ tasks.withType<Test> {
         setExceptionFormat("full")
     }
 }
+
+sourceSets {
+    main {
+        blossom {
+            kotlinSources {
+                fun generateLicenseHeader() : String {
+                    val builder = StringBuilder()
+                    builder.append("/*\n")
+                    rootProject.file("HEADER").forEachLine {
+                        if(it.isEmpty()) {
+                            builder.append(" *").append("\n")
+                        } else {
+                            builder.append(" * ").append(it).append("\n")
+                        }
+                    }
+
+                    return builder.append(" */").append("\n").toString()
+                }
+
+                property("license", generateLicenseHeader())
+                property("modid", "cobblemon")
+                property("version", project.version())
+                property("isSnapshot", if(rootProject.isSnapshot()) "true" else "false")
+                property("gitCommit", versioning.info.commit)
+                property("branch", versioning.info.branch)
+                System.getProperty("buildNumber")?.let { property("buildNumber", it) }
+                property("timestamp", OffsetDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ofPattern("MM/dd/yyyy hh:mm:ss")) + " UTC")
+            }
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/DoubleJump.java

@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common;
+
+public interface DoubleJump {
+    boolean isDoubleJumping();
+}

common/src/main/java/com/cobblemon/mod/common/OrientationControllable.java

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common;
+
+import com.cobblemon.mod.common.api.orientation.OrientationController;
+
+public interface OrientationControllable {
+    OrientationController getOrientationController();
+}

common/src/main/java/com/cobblemon/mod/common/access/SoundManagerDuck.java

@@ -1,15 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.access;
-
-import net.minecraft.sound.SoundCategory;
-
-public interface SoundManagerDuck {
-    void toggleCategories(SoundCategory... categories);
-}

common/src/main/java/com/cobblemon/mod/common/bridges/StructureProcessorListBridge.java

@@ -8,7 +8,7 @@
 
 package com.cobblemon.mod.common.bridges;
 
-import net.minecraft.structure.processor.StructureProcessor;
+import net.minecraft.world.level.levelgen.structure.templatesystem.StructureProcessor;
 
 public interface StructureProcessorListBridge {
     void append(StructureProcessor processor);

common/src/main/java/com/cobblemon/mod/common/client/render/models/blockbench/pose/Bone.java

@@ -8,13 +8,9 @@
 
 package com.cobblemon.mod.common.client.render.models.blockbench.pose;
 
-import com.cobblemon.mod.common.client.render.models.blockbench.PoseableEntityModel;
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext;
-import net.minecraft.client.render.VertexConsumer;
-import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.entity.Entity;
-import org.jetbrains.annotations.Nullable;
-
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
 import java.util.Map;
 
 /**
@@ -45,23 +41,17 @@ public interface Bone {
      * @param buffer The vertex consumer deployed by the renderer
      * @param packedLight The light level to be applied to the bone
      * @param packedOverlay The overlay value to be applied to the bone
-     * @param r A value representing the amount of red coloring that should be applied on the RGB scale
-     * @param g A value representing the amount of green coloring that should be applied on the RGB scale
-     * @param b A value representing the amount of blue coloring that should be applied on the RGB scale
-     * @param a The alpha value to apply to the model based on the RGB scale
+     * @param color RGBA packed integer color value
      *
      * @since 1.4.0
      */
     void render(
             RenderContext context,
-            MatrixStack stack,
+            PoseStack stack,
             VertexConsumer buffer,
             int packedLight,
             int packedOverlay,
-            float r,
-            float g,
-            float b,
-            float a
+            int color
     );
 
     /**
@@ -69,5 +59,5 @@ public interface Bone {
      *
      * @since 1.4.0
      */
-    void transform(MatrixStack matrixStack);
+    void transform(PoseStack matrixStack);
 }

common/src/main/java/com/cobblemon/mod/common/compat/lambdynamiclights/CustomLuminance.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.compat.lambdynamiclights;
+
+import com.cobblemon.mod.common.pokemon.FormData;
+import com.cobblemon.mod.common.pokemon.lighthing.LightingData;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Optional;
+
+public abstract class CustomLuminance {
+    protected static Optional<Integer> extractFormLightLevel(@NotNull FormData form, boolean underwater) {
+        if (form.getLightingData() == null || !liquidGlowModeSupport(form.getLightingData().getLiquidGlowMode(), underwater)) {
+            return Optional.empty();
+        }
+        return Optional.of(form.getLightingData().getLightLevel());
+    }
+
+    protected static boolean liquidGlowModeSupport(@NotNull LightingData.LiquidGlowMode liquidGlowMode, boolean underwater) {
+        return underwater ? liquidGlowMode.getGlowsUnderwater() : liquidGlowMode.getGlowsInLand();
+    }
+}

common/src/main/java/com/cobblemon/mod/common/compat/lambdynamiclights/LambDynamicLightsInitializer.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.compat.lambdynamiclights;
+
+import com.cobblemon.mod.common.Cobblemon;
+import dev.lambdaurora.lambdynlights.api.DynamicLightsContext;
+import dev.lambdaurora.lambdynlights.api.DynamicLightsInitializer;
+import dev.lambdaurora.lambdynlights.api.entity.luminance.EntityLuminance;
+import dev.lambdaurora.lambdynlights.api.item.ItemLightSourceManager;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.EntityType;
+
+public class LambDynamicLightsInitializer implements DynamicLightsInitializer {
+    public static final EntityLuminance.Type POKEMON_LUMINANCE = EntityLuminance.Type.registerSimple(
+            ResourceLocation.fromNamespaceAndPath(Cobblemon.MODID, "pokemon"),
+            PokemonLuminance.INSTANCE
+    );
+    public static final EntityLuminance.Type PLAYER_LUMINANCE = EntityLuminance.Type.registerSimple(
+            ResourceLocation.fromNamespaceAndPath(Cobblemon.MODID, "shoulder"),
+            PlayerLuminance.INSTANCE
+    );
+
+    @Override
+    public void onInitializeDynamicLights(DynamicLightsContext context) {
+        Cobblemon.LOGGER.info("Lamb Dynamic Lights compatibility enabled");
+
+        context.entityLightSourceManager().onRegisterEvent().register(ctx -> {
+            ctx.register(EntityType.PLAYER, PlayerLuminance.INSTANCE);
+        });
+    }
+
+    @SuppressWarnings({"removal", "UnstableApiUsage"})
+    @Override
+    public void onInitializeDynamicLights(ItemLightSourceManager itemLightSourceManager) {}
+}
+

common/src/main/java/com/cobblemon/mod/common/compat/lambdynamiclights/PlayerLuminance.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.compat.lambdynamiclights;
+
+import com.cobblemon.mod.common.Cobblemon;
+import com.cobblemon.mod.common.client.render.layer.PokemonOnShoulderRenderer;
+import dev.lambdaurora.lambdynlights.api.entity.luminance.EntityLuminance;
+import dev.lambdaurora.lambdynlights.api.item.ItemLightSourceManager;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Range;
+
+public final class PlayerLuminance extends CustomLuminance implements EntityLuminance {
+    public static final PlayerLuminance INSTANCE = new PlayerLuminance();
+    private static final TagKey<Item> POKEDEX = TagKey.create(Registries.ITEM, ResourceLocation.fromNamespaceAndPath(Cobblemon.MODID, "pokedex"));
+
+    @Override
+    public @NotNull Type type() {
+        return LambDynamicLightsInitializer.PLAYER_LUMINANCE;
+    }
+
+    @Override
+    public @Range(from = 0L, to = 15L) int getLuminance(@NotNull ItemLightSourceManager itemLightSourceManager, @NotNull Entity entity) {
+        if (entity instanceof Player player) {
+            final int shoulderLightLevel = shoulderLuminance(itemLightSourceManager, player);
+
+            final int itemLightLevel = player.isHolding(stack -> stack.is(POKEDEX)) ? 13 : 0;
+
+            return Math.max(shoulderLightLevel, itemLightLevel);
+        } else {
+            return 0;
+        }
+    }
+
+    private @Range(from = 0L, to = 15L) static int shoulderLuminance(@NotNull ItemLightSourceManager itemLightSourceManager, @NotNull Player player) {
+        final var leftShoulder = PokemonOnShoulderRenderer.shoulderDataFrom(player.getShoulderEntityLeft());
+        final var rightShoulder = PokemonOnShoulderRenderer.shoulderDataFrom(player.getShoulderEntityRight());
+
+        if (leftShoulder == null && rightShoulder == null) {
+            return 0;
+        }
+
+        final int leftShoulderLightLevel = extractShoulderLightLevel(leftShoulder, itemLightSourceManager, player.isUnderWater());
+        final int rightShoulderLightLevel = extractShoulderLightLevel(rightShoulder, itemLightSourceManager, player.isUnderWater());
+        return Math.max(leftShoulderLightLevel, rightShoulderLightLevel);
+    }
+
+    private static int extractShoulderLightLevel(@Nullable PokemonOnShoulderRenderer.ShoulderData shoulderData, @NotNull ItemLightSourceManager itemLightSourceManager, boolean underwater) {
+        if (shoulderData == null) {
+            return 0;
+        }
+
+        ItemStack item = shoulderData.getShownItem();
+        int itemLightLevel = item.isEmpty() ? 0 : itemLightSourceManager.getLuminance(item, underwater);
+        int formLightLevel = extractFormLightLevel(shoulderData.getForm(), underwater).orElse(0);
+
+        return Math.max(itemLightLevel, formLightLevel);
+    }
+}

common/src/main/java/com/cobblemon/mod/common/compat/lambdynamiclights/PokemonLuminance.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.compat.lambdynamiclights;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import dev.lambdaurora.lambdynlights.api.entity.luminance.EntityLuminance;
+import dev.lambdaurora.lambdynlights.api.item.ItemLightSourceManager;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.item.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Range;
+
+public final class PokemonLuminance extends CustomLuminance implements EntityLuminance {
+    public static final PokemonLuminance INSTANCE = new PokemonLuminance();
+
+    private PokemonLuminance() {}
+
+    @Override
+    public @NotNull Type type() {
+        return LambDynamicLightsInitializer.POKEMON_LUMINANCE;
+    }
+
+    @Override
+    public @Range(from = 0L, to = 15L) int getLuminance(
+            @NotNull ItemLightSourceManager itemLightSourceManager,
+            @NotNull Entity entity
+    ) {
+        if (entity instanceof PokemonEntity pokemon) {
+            boolean underwater = pokemon.isUnderWater();
+            ItemStack item = pokemon.getShownItem();
+            int itemLightLevel = item.isEmpty() ? 0 : itemLightSourceManager.getLuminance(item, underwater);
+            int formLightLevel = extractFormLightLevel(pokemon.getForm(), underwater).orElse(0);
+
+            return Math.max(itemLightLevel, formLightLevel);
+        } else {
+            return 0;
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/duck/ChannelDuck.java

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.duck;
+
+public interface ChannelDuck {
+    void cobblemon$applyLowPassFilter(float gain, float hfGain);
+    void cobblemon$inverseAttenuation(float rolloffFactor);
+    void cobblemon$clearFilters();
+
+//    void cobblemon$exponentialAttenuation(float rolloff, float refDistance, float maxDistance);
+}

common/src/main/java/com/cobblemon/mod/common/duck/PlayerDuck.java

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.duck;
+
+import org.joml.Vector3f;
+
+public interface PlayerDuck {
+	void setDriverInput(Vector3f driverInput);
+	Vector3f getDriverInput();
+	void setLastSentDriverInput(Vector3f driverInput);
+	Vector3f getLastSentDriverInput();
+}

common/src/main/java/com/cobblemon/mod/common/duck/RecipeAwareSlot.java

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.duck;
+
+import net.minecraft.world.item.crafting.RecipeManager;
+
+public interface RecipeAwareSlot {
+	void setRecipeManager(RecipeManager recipeManager);
+}

common/src/main/java/com/cobblemon/mod/common/duck/SoundEngineDuck.java

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.duck;
+
+import org.jetbrains.annotations.Nullable;
+
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.sounds.SoundSource;
+
+public interface SoundEngineDuck {
+
+    void pauseSounds(@Nullable ResourceLocation id, @Nullable SoundSource category);
+
+    void resumeSounds(@Nullable ResourceLocation id, @Nullable SoundSource category);
+}

common/src/main/java/com/cobblemon/mod/common/duck/SoundManagerDuck.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.duck;
+
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.sounds.SoundSource;
+import org.jetbrains.annotations.Nullable;
+
+public interface SoundManagerDuck {
+
+    void pauseSounds(@Nullable ResourceLocation id, @Nullable SoundSource category);
+
+    void resumeSounds(@Nullable ResourceLocation id, @Nullable SoundSource category);
+}

common/src/main/java/com/cobblemon/mod/common/mixin/BeeEntityMixin.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.block.SaccharineLeafBlock;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.ModifyVariable;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+
+
+@Mixin(targets = "net.minecraft.world.entity.animal.Bee$BeeGrowCropGoal")
+public abstract class BeeEntityMixin {
+
+    @Unique
+    private BlockState cobblemon$result = null;
+
+    @Inject(method = "tick()V", at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/world/level/block/BonemealableBlock;performBonemeal(Lnet/minecraft/server/level/ServerLevel;Lnet/minecraft/util/RandomSource;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/state/BlockState;)V",
+            shift = At.Shift.BY,
+            by = 2
+        ),
+        locals = LocalCapture.CAPTURE_FAILHARD
+    )
+    private void injectCustomGrowth(CallbackInfo ci, int i, BlockPos blockPos, BlockState blockState, Block block) {
+        if (block instanceof SaccharineLeafBlock) {
+
+            int age = blockState.getValue(SaccharineLeafBlock.Companion.getAGE());
+            boolean waterlogged = blockState.getValue(BlockStateProperties.WATERLOGGED);
+
+            if (age < 2 && !waterlogged) {
+                this.cobblemon$result = blockState.setValue(SaccharineLeafBlock.Companion.getAGE(), age + 1);
+            }
+        }
+    }
+
+    @ModifyVariable(method = "tick", at = @At(value = "LOAD", ordinal = 0), index = 5)
+    private BlockState applyCustomBlockState(BlockState before) {
+        if(this.cobblemon$result != null && before == null) {
+            BlockState result = this.cobblemon$result;
+            this.cobblemon$result = null;
+            return result;
+        }
+
+        return before;
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/BuiltinModelItemRendererMixin.java

@@ -10,22 +10,21 @@ package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.client.render.item.CobblemonBuiltinItemRenderer;
 import com.cobblemon.mod.common.client.render.item.CobblemonBuiltinItemRendererRegistry;
-import net.minecraft.client.render.VertexConsumerProvider;
-import net.minecraft.client.render.item.BuiltinModelItemRenderer;
-import net.minecraft.client.render.model.json.ModelTransformation;
-import net.minecraft.client.render.model.json.ModelTransformationMode;
-import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.item.ItemStack;
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.renderer.BlockEntityWithoutLevelRenderer;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.world.item.ItemDisplayContext;
+import net.minecraft.world.item.ItemStack;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-@Mixin(BuiltinModelItemRenderer.class)
+@Mixin(BlockEntityWithoutLevelRenderer.class)
 public class BuiltinModelItemRendererMixin {
 
-    @Inject(method = "render", at = @At("HEAD"), cancellable = true)
-    private void cobblemon$useDynamicItemRenderer(ItemStack stack, ModelTransformationMode mode, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay, CallbackInfo ci) {
+    @Inject(method = "renderByItem", at = @At("HEAD"), cancellable = true)
+    private void cobblemon$useDynamicItemRenderer(ItemStack stack, ItemDisplayContext mode, PoseStack matrices, MultiBufferSource vertexConsumers, int light, int overlay, CallbackInfo ci) {
         CobblemonBuiltinItemRenderer renderer = CobblemonBuiltinItemRendererRegistry.INSTANCE.rendererOf(stack.getItem());
         if (renderer != null) {
             renderer.render(stack, mode, matrices, vertexConsumers, light, overlay);

common/src/main/java/com/cobblemon/mod/common/mixin/ChannelMixin.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+import com.cobblemon.mod.common.duck.ChannelDuck;
+import com.mojang.blaze3d.audio.Channel;
+import org.lwjgl.openal.AL10;
+import org.lwjgl.openal.EXTEfx;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+
+@Mixin(Channel.class)
+public abstract class ChannelMixin implements ChannelDuck {
+
+    @Shadow
+    private int source;
+
+    // Id of filter applied when sound is obstructed
+    private int cobblemon$lowPassFilterId = 0;
+
+    @Override
+    public void cobblemon$applyLowPassFilter(float gain, float hfGain) {
+        // Delete old filter if it exists
+        if (cobblemon$lowPassFilterId != 0) {
+            AL10.alSourcei(source, EXTEfx.AL_DIRECT_FILTER, 0); // Detach filter from source
+            EXTEfx.alDeleteFilters(cobblemon$lowPassFilterId);  // Delete old filter
+            cobblemon$lowPassFilterId = 0;
+        }
+
+        // Generate a fresh filter
+        int filterId = EXTEfx.alGenFilters();
+        if (!EXTEfx.alIsFilter(filterId)) {
+            System.err.println("Failed to create OpenAL low-pass filter");
+            return;
+        }
+
+        EXTEfx.alFilteri(filterId, EXTEfx.AL_FILTER_TYPE, EXTEfx.AL_FILTER_LOWPASS);
+        EXTEfx.alFilterf(filterId, EXTEfx.AL_LOWPASS_GAIN, gain);
+        EXTEfx.alFilterf(filterId, EXTEfx.AL_LOWPASS_GAINHF, hfGain);
+
+        AL10.alSourcei(source, EXTEfx.AL_DIRECT_FILTER, filterId);
+
+        // Save the new filter ID
+        cobblemon$lowPassFilterId = filterId;
+    }
+
+    @Override
+    public void cobblemon$inverseAttenuation(float rolloffFactor) {
+        AL10.alSourcei(source, AL10.AL_DISTANCE_MODEL, AL10.AL_INVERSE_DISTANCE);
+        AL10.alSourcef(source, AL10.AL_ROLLOFF_FACTOR,    rolloffFactor);
+        AL10.alSourcef(source, AL10.AL_REFERENCE_DISTANCE, 1.0f);
+        AL10.alSourcef(source, AL10.AL_MAX_DISTANCE,       0.0f);
+    }
+
+    @Override
+    public void cobblemon$clearFilters() {
+        AL10.alSourcei(source, EXTEfx.AL_DIRECT_FILTER, 0);
+
+        if (EXTEfx.alIsFilter(cobblemon$lowPassFilterId)) {
+            EXTEfx.alDeleteFilters(cobblemon$lowPassFilterId);
+            cobblemon$lowPassFilterId = 0;
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/ChunkStorageMixin.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import static com.cobblemon.mod.common.datafixer.CobblemonSchemas.VERSION_KEY;
+
+import com.cobblemon.mod.common.datafixer.CobblemonSchemas;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.mojang.serialization.MapCodec;
+import java.util.Optional;
+import java.util.function.Supplier;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.IntTag;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.util.datafix.DataFixTypes;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.chunk.storage.ChunkStorage;
+import net.minecraft.world.level.storage.DimensionDataStorage;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.ModifyVariable;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(ChunkStorage.class)
+public class ChunkStorageMixin {
+    //Modifies the NBT returned by the vanilla upgradeChunkTag to also incorporate cobblemon fixup stuff
+    @ModifyExpressionValue(
+        method = "upgradeChunkTag(Lnet/minecraft/resources/ResourceKey;Ljava/util/function/Supplier;Lnet/minecraft/nbt/CompoundTag;Ljava/util/Optional;)Lnet/minecraft/nbt/CompoundTag;",
+        at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/util/datafix/DataFixTypes;updateToCurrentVersion(Lcom/mojang/datafixers/DataFixer;Lnet/minecraft/nbt/CompoundTag;I)Lnet/minecraft/nbt/CompoundTag;"
+        )
+    )
+    public CompoundTag cobblemon$doChunkFix(
+        CompoundTag vanillaFixed
+    ) {
+        int curVersion = vanillaFixed.contains(VERSION_KEY) ? vanillaFixed.getInt(VERSION_KEY) : 0;
+        return DataFixTypes.CHUNK.update(CobblemonSchemas.getDATA_FIXER(), vanillaFixed, curVersion, CobblemonSchemas.DATA_VERSION);
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/ClientPacketListenerMixin.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.multiplayer.ClientPacketListener;
+import net.minecraft.network.protocol.game.ClientboundSetPassengersPacket;
+import net.minecraft.world.entity.Entity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Objects;
+
+@Mixin(ClientPacketListener.class)
+public class ClientPacketListenerMixin {
+
+    @Shadow private ClientLevel level;
+
+    @Inject(method = "handleSetEntityPassengersPacket", at = @At(value = "INVOKE_ASSIGN", target = "Lnet/minecraft/world/entity/Entity;hasIndirectPassenger(Lnet/minecraft/world/entity/Entity;)Z", shift = At.Shift.BEFORE), cancellable = true)
+    private void cobblemon$handlePokemonPassengers(ClientboundSetPassengersPacket packet, CallbackInfo ci) {
+        Entity entity = this.level.getEntity(packet.getVehicle());
+        if (entity instanceof PokemonEntity pokemon) {
+            var passengers = new ArrayList<Entity>();
+            for (int passenger : packet.getPassengers()) {
+                passengers.add(this.level.getEntity(passenger));
+            }
+            Arrays
+                    .stream(pokemon.getOccupiedSeats())
+                    .filter(x -> !passengers.contains(x))
+                    .filter(Objects::nonNull)
+                    .forEach(Entity::stopRiding);
+
+            var occupiedSeats = Arrays.asList(pokemon.getOccupiedSeats());
+            passengers.stream()
+                    .filter(x -> !occupiedSeats.contains(x))
+                    .filter(Objects::nonNull)
+                    .forEach(x -> x.startRiding(pokemon, true));
+            ci.cancel();
+        }
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/CrashReportMixin.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.CobblemonBuildDetails;
+import net.minecraft.CrashReport;
+import net.minecraft.CrashReportCategory;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(CrashReport.class)
+public final class CrashReportMixin {
+
+    @Inject(method = "getDetails(Ljava/lang/StringBuilder;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/SystemReport;appendToCrashReportString(Ljava/lang/StringBuilder;)V"))
+    public void cobblemon$printCobblemonDetails(StringBuilder builder, CallbackInfo callback) {
+        CrashReportCategory cobblemon = new CrashReportCategory("Cobblemon");
+        cobblemon.setDetail("Version", CobblemonBuildDetails.VERSION);
+        cobblemon.setDetail("Is Snapshot", CobblemonBuildDetails.SNAPSHOT);
+        cobblemon.setDetail("Git Commit", CobblemonBuildDetails.INSTANCE.smallCommitHash() + " (" + "https://gitlab.com/cable-mc/cobblemon/-/commit/" + CobblemonBuildDetails.GIT_COMMIT + ")");
+        cobblemon.setDetail("Branch", CobblemonBuildDetails.BRANCH);
+
+        cobblemon.getDetails(builder);
+        builder.append("\n\n");
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/DecoratedPotPatternsMixin.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.sherds.CobblemonSherds;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.level.block.entity.DecoratedPotPattern;
+import net.minecraft.world.level.block.entity.DecoratedPotPatterns;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(DecoratedPotPatterns.class)
+public abstract class DecoratedPotPatternsMixin {
+    @Inject(method = "getPatternFromItem", at=@At("HEAD"), cancellable = true)
+    private static void cobblemon$getCobblemonSherdTexture(
+        Item sherd,
+        CallbackInfoReturnable<ResourceKey<DecoratedPotPattern>> cir
+    ) {
+        if (CobblemonSherds.INSTANCE.getSherdToPattern().containsKey(sherd)) {
+            cir.setReturnValue(CobblemonSherds.INSTANCE.getSherdToPattern().get(sherd));
+            cir.cancel();
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/EnderPearlItemMixin.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.EnderpearlItem;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec3;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.Comparator;
+
+@Mixin(EnderpearlItem.class)
+public abstract class EnderPearlItemMixin {
+    @Inject(method = "use", at = @At(value = "HEAD"), cancellable = true)
+    private void cobblemon$use(Level level, Player player, InteractionHand usedHand, CallbackInfoReturnable<InteractionResultHolder<ItemStack>> cir) {
+        double range = player.entityInteractionRange();
+        Entity closestEntity = level.getEntities(player, AABB.ofSize(player.position(), range, range, range)).stream()
+            .filter(entity -> isLookingAt(player, entity))
+            .min(Comparator.comparingDouble(entity -> entity.distanceTo(player)))
+            .orElse(null);
+
+        if (closestEntity instanceof PokemonEntity pokemonEntity) {
+            if (player.isCrouching() && pokemonEntity.getOwnerUUID() == player.getUUID()) {
+                cir.cancel();
+            }
+        }
+    }
+
+    public boolean isLookingAt(Player player, Entity other) {
+        float maxDistance = 10F;
+        float stepDistance = 0.1F;
+        double step = stepDistance;
+        Vec3 startPos = player.getEyePosition();
+        Vec3 direction = player.getLookAngle();
+
+        while (step <= maxDistance) {
+            Vec3 location = startPos.add(direction.scale(step));
+            step += stepDistance;
+
+            if (other.getBoundingBox().contains(location)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/EntityCreeperMixin.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.cobblemon.mod.common.pokemon.ai.EntityBehaviour;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.ai.goal.AvoidEntityGoal;
+import net.minecraft.world.entity.monster.Creeper;
+import net.minecraft.world.level.Level;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(Creeper.class)
+public class EntityCreeperMixin extends Mob {
+
+    private EntityCreeperMixin(net.minecraft.world.entity.EntityType<? extends Creeper> entityType, Level world) {
+        super(entityType, world);
+    }
+
+    @Inject(method = "registerGoals", at = @At(value = "TAIL"), cancellable = false)
+    private void cobblemon$initGoals(CallbackInfo callbackInfo) {
+        final Creeper creeper = (Creeper) (Object) this;
+        // Pokemon Entities
+        this.goalSelector.addGoal(
+            3,
+            new AvoidEntityGoal<>(
+                creeper,
+                PokemonEntity.class,
+                6.0f,
+                1.0,
+                1.2,
+                 entity -> ((PokemonEntity)entity).getBehaviour().getEntityInteract().getAvoidedByCreeper() && ((PokemonEntity)entity).getBeamMode() != 1
+            )
+        );
+
+        // Players with shoulder mounted Pokemon
+        this.goalSelector.addGoal(
+            3,
+            new AvoidEntityGoal<>(
+                creeper,
+                ServerPlayer.class,
+                6.0f,
+                1.0,
+                1.2,
+                entity -> EntityBehaviour.Companion.hasCreeperFearedShoulderMount((ServerPlayer)entity)
+            )
+        );
+
+    }
+}
+

common/src/main/java/com/cobblemon/mod/common/mixin/EntityFoxMixin.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.cobblemon.mod.common.pokemon.ai.EntityBehaviour;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.ai.goal.AvoidEntityGoal;
+import net.minecraft.world.entity.animal.Fox;
+import net.minecraft.world.entity.monster.Creeper;
+import net.minecraft.world.level.Level;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(Fox.class)
+public class EntityFoxMixin extends Mob {
+
+    private EntityFoxMixin(net.minecraft.world.entity.EntityType<? extends Creeper> entityType, Level world) {
+        super(entityType, world);
+    }
+
+    @Inject(method = "registerGoals", at = @At(value = "TAIL"), cancellable = false)
+    private void cobblemon$initGoals(CallbackInfo callbackInfo) {
+        final Fox fox = (Fox) (Object) this;
+        // Pokemon Entities
+        this.goalSelector.addGoal(
+            4,
+            new AvoidEntityGoal<>(
+                    fox,
+                PokemonEntity.class,
+                8.0f,
+                1.6,
+                1.4,
+                 entity -> ((PokemonEntity)entity).getBehaviour().getEntityInteract().getAvoidedByFox() && ((PokemonEntity)entity).getBeamMode() != 1
+            )
+        );
+
+        // Players with shoulder mounted Pokemon
+        this.goalSelector.addGoal(
+            3,
+            new AvoidEntityGoal<>(
+                fox,
+                ServerPlayer.class,
+                8.0f,
+                1.6,
+                1.4,
+                entity -> EntityBehaviour.Companion.hasFoxFearedShoulderMount((ServerPlayer)entity)
+            )
+        );
+
+    }
+}
+

common/src/main/java/com/cobblemon/mod/common/mixin/EntityRenderDispatcherMixin.java

@@ -9,10 +9,19 @@
 package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.client.CobblemonClient;
-import net.minecraft.client.render.entity.EntityRenderDispatcher;
-import net.minecraft.client.render.entity.EntityRenderer;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.resource.ResourceManager;
+import com.cobblemon.mod.common.client.render.models.blockbench.PosableState;
+import com.cobblemon.mod.common.entity.PosableEntity;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import net.minecraft.client.renderer.LevelRenderer;
+import net.minecraft.client.renderer.entity.EntityRenderDispatcher;
+import net.minecraft.client.renderer.entity.EntityRenderer;
+import net.minecraft.client.resources.PlayerSkin;
+import net.minecraft.server.packs.resources.ResourceManager;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec3;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
@@ -24,13 +33,65 @@ import java.util.Map;
 @Mixin(EntityRenderDispatcher.class)
 public class EntityRenderDispatcherMixin {
 
-    @Shadow private Map<String, EntityRenderer<? extends PlayerEntity>> modelRenderers;
+    @Shadow private Map<PlayerSkin.Model, EntityRenderer<? extends Player>> playerRenderers;
 
     @Inject(
-        method = "reload",
+        method = "onResourceManagerReload",
         at = @At(value = "TAIL")
     )
     public void resourceManagerReloadHook(ResourceManager resourceManager, CallbackInfo ci) {
-        CobblemonClient.INSTANCE.onAddLayer(this.modelRenderers);
+        CobblemonClient.INSTANCE.onAddLayer(this.playerRenderers);
     }
-}
+
+    @Inject(
+        method = "renderHitbox(Lcom/mojang/blaze3d/vertex/PoseStack;Lcom/mojang/blaze3d/vertex/VertexConsumer;Lnet/minecraft/world/entity/Entity;FFFF)V",
+        at = @At(value = "TAIL")
+    )
+    private static void renderLocators(
+        PoseStack poseStack,
+        VertexConsumer buffer,
+        Entity entity,
+        float red,
+        float green,
+        float blue,
+        float alpha,
+        CallbackInfo ci
+    ) {
+        if (entity instanceof PosableEntity posableEntity) {
+            if (posableEntity.getDelegate() instanceof PosableState state) {
+                state.getLocatorStates().forEach((locator, matrix) -> {
+                    poseStack.pushPose();
+                    Vec3 pos = matrix.getOrigin().subtract(entity.position());
+                    LevelRenderer.renderLineBox(
+                        poseStack,
+                        buffer,
+                        AABB.ofSize(pos, 0.25, 0.25, 0.25),
+                        0F,
+                        1F,
+                        0F,
+                        1F
+                    );
+
+                    /*if (locator.contains("middle")){
+                        PoseStack.Pose pose = poseStack.last();
+                        Vector3f vec = matrix.getMatrix().getRotation(new AxisAngle4f()).transform(new Vector3f(0, 0, -1));
+                        buffer.addVertex(pose, pos.toVector3f()).setColor(0xffff00ff).setNormal(pose, vec.x, vec.y, vec.z); //Forward, pink
+                        buffer.addVertex(pose, (float)(pos.x() + vec.x), (float)(pos.y() + vec.y), (float)(pos.z() + vec.z)).setColor(0xffff00ff).setNormal(pose, vec.x, vec.y, vec.z);
+
+                        vec = matrix.getMatrix().getRotation(new AxisAngle4f()).transform(new Vector3f(0, 1, 0));
+                        buffer.addVertex(pose, pos.toVector3f()).setColor(0xffffff00).setNormal(pose, vec.x, vec.y, vec.z); //Up, yellow
+                        buffer.addVertex(pose, (float)(pos.x() + vec.x), (float)(pos.y() + vec.y), (float)(pos.z() + vec.z)).setColor(0xffffff00).setNormal(pose, vec.x, vec.y, vec.z);
+
+                        vec = matrix.getMatrix().getRotation(new AxisAngle4f()).transform(new Vector3f(-1, 0, 0));
+                        buffer.addVertex(pose, pos.toVector3f()).setColor(0xff00ffff).setNormal(pose, vec.x, vec.y, vec.z); //Left, cyan
+                        buffer.addVertex(pose, (float)(pos.x() + vec.x), (float)(pos.y() + vec.y), (float)(pos.z() + vec.z)).setColor(0xff00ffff).setNormal(pose, vec.x, vec.y, vec.z);
+                    }*/
+
+
+                    poseStack.popPose();
+                });
+
+            }
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/EntitySkeletonMixin.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.cobblemon.mod.common.pokemon.ai.EntityBehaviour;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.ai.goal.AvoidEntityGoal;
+import net.minecraft.world.entity.monster.AbstractSkeleton;
+import net.minecraft.world.level.Level;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(AbstractSkeleton.class)
+public class EntitySkeletonMixin extends Mob {
+
+    private EntitySkeletonMixin(EntityType<? extends Mob> entityType, Level world) {
+        super(entityType, world);
+    }
+
+    @Inject(method = "registerGoals", at = @At(value = "TAIL"))
+    private void cobblemon$initGoals(CallbackInfo callbackInfo) {
+        final AbstractSkeleton skeleton = (AbstractSkeleton) (Object) this;
+        // Pokemon Entities
+        this.goalSelector.addGoal(
+            3,
+            new AvoidEntityGoal<>(
+                skeleton,
+                PokemonEntity.class,
+                6.0f,
+                1.0,
+                1.2,
+                 entity -> ((PokemonEntity)entity).getBehaviour().getEntityInteract().getAvoidedBySkeleton() && ((PokemonEntity)entity).getBeamMode() != 1
+            )
+        );
+
+        // Players with shoulder mounted Pokemon
+        this.goalSelector.addGoal(
+            3,
+            new AvoidEntityGoal<>(
+                skeleton,
+                ServerPlayer.class,
+                6.0f,
+                1.0,
+                1.2,
+                entity -> EntityBehaviour.Companion.hasSkeletonFearedShoulderMount((ServerPlayer)entity)
+            )
+        );
+
+    }
+}
+

common/src/main/java/com/cobblemon/mod/common/mixin/EntityStorageMixin.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import static com.cobblemon.mod.common.datafixer.CobblemonSchemas.VERSION_KEY;
+
+import com.cobblemon.mod.common.datafixer.CobblemonSchemas;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.IntTag;
+import net.minecraft.util.datafix.DataFixTypes;
+import net.minecraft.world.level.chunk.storage.EntityStorage;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+@Mixin(EntityStorage.class)
+public class EntityStorageMixin {
+    //Modifies the NBT returned by the vanilla upgradeChunkTag to also incorporate cobblemon fixup stuff
+    @ModifyExpressionValue(
+        method = "method_31731(Lnet/minecraft/world/level/ChunkPos;Ljava/util/Optional;)Lnet/minecraft/world/level/entity/ChunkEntities;",
+        at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/world/level/chunk/storage/SimpleRegionStorage;upgradeChunkTag(Lnet/minecraft/nbt/CompoundTag;I)Lnet/minecraft/nbt/CompoundTag;"
+        )
+    )
+    public CompoundTag cobblemon$doEntityFix(
+        CompoundTag vanillaFixed
+    ) {
+        int curVersion = vanillaFixed.contains(VERSION_KEY) ? vanillaFixed.getInt(VERSION_KEY) : 0;
+        CompoundTag newTag =  DataFixTypes.ENTITY_CHUNK.update(CobblemonSchemas.getDATA_FIXER(), vanillaFixed, curVersion, CobblemonSchemas.DATA_VERSION);
+        newTag.put(VERSION_KEY, IntTag.valueOf(CobblemonSchemas.DATA_VERSION));
+        return newTag;
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/EntityVillagerMixin.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import com.cobblemon.mod.common.villager.VillagerGatherableItems;
+
+import java.util.Objects;
+import net.minecraft.world.entity.npc.Villager;
+import net.minecraft.world.entity.npc.VillagerProfession;
+import net.minecraft.world.item.ItemStack;
+
+@Mixin(Villager.class)
+public abstract class EntityVillagerMixin {
+
+    @Inject(method = "wantsToPickUp", at = @At(value = "RETURN"), cancellable = true)
+    private void cobblemon$canGather(ItemStack stack, CallbackInfoReturnable<Boolean> ci) {
+        final Villager villager = (Villager) (Object) this;
+        if (ci.getReturnValue() == false && Objects.equals(villager.getVillagerData().getProfession(), VillagerProfession.FARMER) && villager.getInventory().canAddItem(stack)) {
+            if(VillagerGatherableItems.INSTANCE.getVillagerGatherableItems().contains(stack.getItem()))
+                ci.setReturnValue(true);
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/ExplosionMixin.java

@@ -9,10 +9,10 @@
 package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.block.PreEmptsExplosion;
-import net.minecraft.block.BlockState;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-import net.minecraft.world.explosion.Explosion;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.Explosion;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.state.BlockState;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Redirect;
@@ -21,14 +21,14 @@ import org.spongepowered.asm.mixin.injection.Redirect;
 public class ExplosionMixin {
 
     @Redirect(
-            method = "affectWorld",
+            method = "finalizeExplosion",
             at = @At(
                     value = "INVOKE",
-                    target = "Lnet/minecraft/world/World;getBlockState(Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/block/BlockState;",
+                    target = "Lnet/minecraft/world/level/Level;getBlockState(Lnet/minecraft/core/BlockPos;)Lnet/minecraft/world/level/block/state/BlockState;",
                     ordinal = 0
             )
     )
-    public BlockState cobblemon$whenExploded(World world, BlockPos pos) {
+    public BlockState cobblemon$whenExploded(Level world, BlockPos pos) {
         BlockState blockState = world.getBlockState(pos);
         if(blockState.getBlock() instanceof PreEmptsExplosion preExplosionBlock) {
             preExplosionBlock.whenExploded(world, blockState, pos);

common/src/main/java/com/cobblemon/mod/common/mixin/GameRendererMixin.java

@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.mixin;
-
-import com.cobblemon.mod.common.api.scheduling.ScheduledTaskTracker;
-import net.minecraft.client.render.GameRenderer;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(GameRenderer.class)
-public class GameRendererMixin {
-    @Inject(
-            method = "render",
-            at = @At(value = "TAIL")
-    )
-    public void render(float tickDelta, long startTime, boolean tick, CallbackInfo ci) {
-            ScheduledTaskTracker.INSTANCE.update();
-    }
-}

common/src/main/java/com/cobblemon/mod/common/mixin/ItemPropertiesMixin.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.fishing.PokeRodFishingBobberEntity;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.item.ItemProperties;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(ItemProperties.class)
+public class ItemPropertiesMixin {
+
+    // Mixins into the fishing rod's register() lambda expression
+    // Without this, the fishing rod item model appears cast when using a PokeRod in the other hand
+    @Inject(method = "method_27883", at = @At(value = "RETURN", ordinal = 1), cancellable = true)
+    private static void cobblemon$preventRodMixup(ItemStack itemStack, ClientLevel clientLevel, LivingEntity livingEntity, int i, CallbackInfoReturnable<Float> cir) {
+        if (!(livingEntity instanceof Player) || ((Player) livingEntity).fishing instanceof PokeRodFishingBobberEntity) {
+            cir.setReturnValue(0.0f);
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/ItemStackComponentizationFixMixin.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.util.DataKeys;
+import com.mojang.serialization.Dynamic;
+import net.minecraft.util.datafix.fixes.ItemStackComponentizationFix;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.stream.Stream;
+
+@Mixin(ItemStackComponentizationFix.class)
+public class ItemStackComponentizationFixMixin
+{
+    @Inject(method = "fixItemStack", at = @At("TAIL"))
+    private static void fixItemStack(ItemStackComponentizationFix.ItemStackData itemStackData, Dynamic<?> dynamic, CallbackInfo ci) {
+        cobblemon$attemptPokemonModelDataFix(itemStackData, dynamic);
+    }
+
+    @Unique
+    private static void cobblemon$attemptPokemonModelDataFix(ItemStackComponentizationFix.ItemStackData itemStackData, Dynamic<?> dynamic)
+    {
+        var species = itemStackData.removeTag(DataKeys.POKEMON_ITEM_SPECIES).asString();
+        var aspects = itemStackData.removeTag(DataKeys.POKEMON_ITEM_ASPECTS).asList(dynamic1 -> dynamic1);
+        var redTint = itemStackData.removeTag(DataKeys.POKEMON_ITEM_TINT_RED).asNumber();
+        var greenTint = itemStackData.removeTag(DataKeys.POKEMON_ITEM_TINT_GREEN).asNumber();
+        var blueTint = itemStackData.removeTag(DataKeys.POKEMON_ITEM_TINT_BLUE).asNumber();
+        var alphaTint = itemStackData.removeTag(DataKeys.POKEMON_ITEM_TINT_ALPHA).asNumber();
+        if(species.hasResultOrPartial() && aspects != null) {
+            var pokeComponent = dynamic.emptyMap().set("species", dynamic.createString(species.getOrThrow()));
+            pokeComponent = pokeComponent.set("aspects", dynamic.createList(aspects.stream()));
+            if(redTint.hasResultOrPartial() || blueTint.hasResultOrPartial() || greenTint.hasResultOrPartial() || alphaTint.hasResultOrPartial()) {
+                pokeComponent = pokeComponent.set("tint", dynamic.createList(Stream.of(redTint, greenTint, blueTint, alphaTint)
+                                                                                     .map(x -> x.mapOrElse(Number::floatValue, error -> 0F))
+                                                                                     .map(dynamic::createFloat)));
+            }
+            itemStackData.setComponent("cobblemon:pokemon_item", pokeComponent);
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/LecternBlockMixin.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.block.entity.LecternBlockEntity;
+import com.cobblemon.mod.common.CobblemonBlocks;
+import com.cobblemon.mod.common.CobblemonSounds;
+import com.cobblemon.mod.common.item.PokedexItem;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.ItemInteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.HorizontalDirectionalBlock;
+import net.minecraft.world.level.block.LecternBlock;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import static net.minecraft.world.level.block.LecternBlock.HAS_BOOK;
+
+@Mixin(LecternBlock.class)
+public abstract class LecternBlockMixin {
+    @Inject(method = "useItemOn", at = @At(value = "HEAD"), cancellable = true)
+    private void cobblemon$useItemOn(ItemStack itemStack, BlockState blockState, Level world, BlockPos blockPos, Player player, InteractionHand interactionHand, BlockHitResult blockHitResult, CallbackInfoReturnable<ItemInteractionResult> cir) {
+        if (!world.isClientSide && itemStack.getItem() instanceof PokedexItem) {
+            BlockEntity blockEntity = world.getBlockEntity(blockPos);
+            if (!blockState.getValue(HAS_BOOK)
+                && blockEntity instanceof net.minecraft.world.level.block.entity.LecternBlockEntity
+                && blockState.getBlock() instanceof LecternBlock
+            ) {
+                ItemStack pokedexItemStack = itemStack.copy();
+                Direction facing = blockState.getValue(HorizontalDirectionalBlock.FACING);
+                itemStack.consumeAndReturn(1, player);
+                blockEntity.setRemoved();
+                BlockState newBlockState = CobblemonBlocks.LECTERN.defaultBlockState().setValue(HorizontalDirectionalBlock.FACING, facing);
+                world.setBlockAndUpdate(blockPos, newBlockState);
+                BlockEntity lecternEntity = world.getBlockEntity(blockPos);
+
+                if (lecternEntity instanceof LecternBlockEntity) {
+                    ((LecternBlockEntity) lecternEntity).setItemStack((pokedexItemStack));
+                    world.playSound(null, blockPos, CobblemonSounds.POKEDEX_CLOSE, SoundSource.BLOCKS, 0.5F, 1.25F);
+                    cir.setReturnValue(ItemInteractionResult.SUCCESS);
+                } else {
+                    cir.setReturnValue(itemStack.isEmpty() && interactionHand == InteractionHand.MAIN_HAND ? ItemInteractionResult.SKIP_DEFAULT_BLOCK_INTERACTION : ItemInteractionResult.PASS_TO_DEFAULT_BLOCK_INTERACTION);
+                }
+            }
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/LightningBoltMixin.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LightningBolt;
+import net.minecraft.world.phys.AABB;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.List;
+
+
+@Mixin(LightningBolt.class)
+public abstract class LightningBoltMixin {
+
+    @Inject(method = "spawnFire", at = @At(value = "Head"), cancellable = true)
+    private void cobblemon$spawnFire(int extraIgnitions, CallbackInfo ci) {
+        // This prevents fire from spawning around Pokemon who otherwise should be immune to lightning and effectively absorb the hit
+        final LightningBolt lightningBolt = (LightningBolt) (Object) this;
+        List<Entity> list = lightningBolt.level().getEntities(
+                lightningBolt,
+                new AABB(lightningBolt.getX() - 2.0, lightningBolt.getY() - 2.0, lightningBolt.getZ() - 2.0, lightningBolt.getX() + 2.0, lightningBolt.getY() + 2.0, lightningBolt.getZ() + 2.0),
+                it -> {
+                    if (!it.isAlive() || !(it instanceof PokemonEntity)) {
+                        return false;
+                    }
+                    String abilityName = ((PokemonEntity) it).getPokemon().getAbility().getName();
+                    return abilityName.equals("lightningrod") || abilityName.equals("voltabsorb") || abilityName.equals("motordrive");
+                });
+        if (!list.isEmpty()) {
+            ci.cancel();
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/LivingEntityMixin.java

@@ -8,23 +8,111 @@
 
 package com.cobblemon.mod.common.mixin;
 
+import com.cobblemon.mod.common.OrientationControllable;
+import com.cobblemon.mod.common.api.orientation.OrientationController;
 import com.cobblemon.mod.common.api.pokemon.effect.ShoulderEffectRegistry;
-import net.minecraft.entity.LivingEntity;
-import net.minecraft.entity.effect.StatusEffectInstance;
-import net.minecraft.server.network.ServerPlayerEntity;
+import com.cobblemon.mod.common.api.riding.Seat;
+import com.cobblemon.mod.common.client.entity.PokemonClientDelegate;
+import com.cobblemon.mod.common.client.render.MatrixWrapper;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.effect.MobEffectInstance;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.level.ClipContext;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.HitResult;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
+import org.joml.Quaternionf;
+import org.joml.Vector3f;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(LivingEntity.class)
-public abstract class LivingEntityMixin {
+public abstract class LivingEntityMixin extends Entity implements OrientationControllable {
 
-    @Inject(method = "onStatusEffectRemoved", at = @At(value = "TAIL"))
-    private void cobblemon$onStatusEffectRemoved(StatusEffectInstance effect, CallbackInfo ci) {
+    public LivingEntityMixin(EntityType<?> entityType, Level level) {
+        super(entityType, level);
+    }
+
+    @Unique
+    private final OrientationController cobblemon$orientationController = new OrientationController((LivingEntity) (Object) this);
+
+    public OrientationController getOrientationController() {
+        return cobblemon$orientationController;
+    }
+
+    @Inject(method = "onEffectRemoved", at = @At(value = "TAIL"))
+    private void cobblemon$onEffectRemoved(MobEffectInstance effect, CallbackInfo ci) {
         final LivingEntity entity = (LivingEntity) (Object) this;
-        if (entity instanceof ServerPlayerEntity) {
-            ShoulderEffectRegistry.INSTANCE.onEffectEnd((ServerPlayerEntity) entity);
+        if (entity instanceof ServerPlayer) {
+            ShoulderEffectRegistry.INSTANCE.onEffectEnd((ServerPlayer) entity);
+        }
+    }
+
+    @Override
+    public @NotNull HitResult pick(double hitDistance, float partialTicks, boolean hitFluids) {
+        Entity vehicle = this.getVehicle();
+        if (vehicle instanceof PokemonEntity pokemonEntity && pokemonEntity.getDelegate() instanceof PokemonClientDelegate delegate) {
+            int seatIndex = pokemonEntity.getPassengers().indexOf(this);
+            Seat seat = pokemonEntity.getSeats().get(seatIndex);
+            MatrixWrapper locator = delegate.getLocatorStates().get(seat.getLocator());
+
+            Vec3 locatorOffset = new Vec3(locator.getMatrix().getTranslation(new Vector3f()));
+
+            Vec3 eyePosition = cobblemon$getEyePosition(partialTicks, pokemonEntity, locatorOffset);
+
+            Vec3 viewVector = this.getViewVector(partialTicks);
+            Vec3 viewDistanceVector = eyePosition.add(viewVector.x * hitDistance, viewVector.y * hitDistance, viewVector.z * hitDistance);
+
+            return this.level()
+                    .clip(
+                            new ClipContext(
+                                    eyePosition, viewDistanceVector, ClipContext.Block.OUTLINE, hitFluids ? net.minecraft.world.level.ClipContext.Fluid.ANY : net.minecraft.world.level.ClipContext.Fluid.NONE, this
+                            )
+                    );
+        }
+
+        return super.pick(hitDistance, partialTicks, hitFluids);
+    }
+
+    @Unique
+    private Vec3 cobblemon$getEyePosition(float partialTicks, PokemonEntity pokemonEntity, Vec3 locatorOffset) {
+        OrientationController controller = this.getOrientationController();
+
+        float currEyeHeight = this.getEyeHeight();
+        Vec3 offset = locatorOffset.add(pokemonEntity.position());
+        if (controller.isActive() && controller.getOrientation() != null) {
+            Quaternionf orientation = controller.getRenderOrientation(partialTicks);
+            Vec3 rotatedEyeHeight = new Vec3(orientation.transform(new Vector3f(0f, currEyeHeight - (this.getBbHeight() / 2), 0f)));
+
+            offset.add(rotatedEyeHeight);
+        }
+
+        return offset;
+    }
+
+    @Inject(method = "tick", at = @At("HEAD"))
+    private void cobblemon$updateRenderOrientation(CallbackInfo ci) {
+        this.cobblemon$orientationController.tick();
+    }
+
+    @Override
+    public void absMoveTo(double x, double y, double z, float yaw, float pitch) {
+        if (cobblemon$orientationController.getActive()) {
+            this.absMoveTo(x, y, z);
+            this.setYRot(yaw % 360.0f);
+            this.setXRot(pitch % 360.0f);
+            this.yRotO = this.getYRot();
+            this.xRotO = this.getXRot();
+        } else {
+            this.absMoveTo(x, y, z);
+            this.absRotateTo(yaw, pitch);
         }
     }
 

common/src/main/java/com/cobblemon/mod/common/mixin/MinecraftDedicatedServerMixin.java

@@ -9,20 +9,20 @@
 package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
-import net.minecraft.entity.Entity;
-import net.minecraft.server.dedicated.DedicatedServer;
-import net.minecraft.server.world.ServerWorld;
+import net.minecraft.server.ServerInterface;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.Entity;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
-@Mixin(ServerWorld.class)
-public abstract class MinecraftDedicatedServerMixin implements DedicatedServer {
+@Mixin(ServerLevel.class)
+public abstract class MinecraftDedicatedServerMixin implements ServerInterface {
 
-    @Inject(method = "shouldCancelSpawn", at = @At(value = "HEAD"), cancellable = true)
+    @Inject(method = "shouldDiscardEntity", at = @At(value = "HEAD"), cancellable = true)
     public void cobblemon$allowPokemonSpawns(Entity entity, CallbackInfoReturnable<Boolean> callback) {
-        if(entity instanceof PokemonEntity) {
+        if (entity instanceof PokemonEntity) {
             callback.setReturnValue(false);
         }
     }

common/src/main/java/com/cobblemon/mod/common/mixin/ModelPartMixin.java

@@ -1,49 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.mixin;
-
-import com.cobblemon.mod.common.client.render.models.blockbench.PoseableEntityModel;
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Bone;
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext;
-import net.minecraft.client.model.ModelPart;
-import net.minecraft.client.render.VertexConsumer;
-import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.entity.Entity;
-import org.jetbrains.annotations.NotNull;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-
-import java.util.Map;
-
-@Mixin(ModelPart.class)
-public abstract class ModelPartMixin implements Bone {
-    @Shadow public abstract void render(MatrixStack matrices, VertexConsumer vertices, int light, int overlay, float red, float green, float blue, float alpha);
-
-    @Shadow public abstract void rotate(MatrixStack matrixStack);
-
-    @Shadow @Final
-    public Map<String, ModelPart> children;
-
-    @NotNull
-    @Override
-    public Map<String, Bone> getChildren() {
-        return (Map<String, Bone>) (Object) children;
-    }
-
-    @Override
-    public void render(RenderContext context, MatrixStack stack, VertexConsumer buffer, int packedLight, int packedOverlay, float r, float g, float b, float a) {
-        this.render(stack, buffer, packedLight, packedOverlay, r, g, b, a);
-    }
-
-    @Override
-    public void transform(MatrixStack matrixStack) {
-        this.rotate(matrixStack);
-    }
-}

common/src/main/java/com/cobblemon/mod/common/mixin/MusicManagerMixin.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.client.sound.BattleMusicController;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.resources.sounds.SoundInstance;
+import net.minecraft.client.sounds.MusicManager;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(MusicManager.class)
+public class MusicManagerMixin {
+
+    @Shadow @Final
+    private Minecraft minecraft;
+
+    @Shadow @Nullable
+    private SoundInstance currentMusic;
+
+    /** Freezes the tracker while a BattleMusicInstance is in progress. Current SoundInstance being tracked will be paused by BattleMusicHandler. */
+    @Inject(method = "tick()V", at = @At("HEAD"), cancellable = true)
+    public void tick(CallbackInfo cb) {
+        if (this.minecraft.getSoundManager().isActive(BattleMusicController.INSTANCE.getMusic())) cb.cancel();
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/NbtUtilsMixin.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import static com.cobblemon.mod.common.datafixer.CobblemonSchemas.VERSION_KEY;
+
+import com.cobblemon.mod.common.datafixer.CobblemonSchemas;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.NbtUtils;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(NbtUtils.class)
+public class NbtUtilsMixin {
+    @Inject(
+        method = "addCurrentDataVersion(Lnet/minecraft/nbt/CompoundTag;)Lnet/minecraft/nbt/CompoundTag;",
+        at = @At("TAIL")
+    )
+    private static void addCobblemonDataVersion(
+        CompoundTag tag,
+        CallbackInfoReturnable<CompoundTag> cir
+    ) {
+        tag.putInt(VERSION_KEY, CobblemonSchemas.DATA_VERSION);
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/ParticleManagerMixin.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.api.snowstorm.ParticleMaterials;
+import com.google.common.collect.ImmutableList;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.List;
+import net.minecraft.client.particle.ParticleEngine;
+import net.minecraft.client.particle.ParticleRenderType;
+
+@Mixin(ParticleEngine.class)
+final class ParticleManagerMixin {
+    @Mutable
+    @Final
+    @Shadow
+    private static List<ParticleRenderType> RENDER_ORDER;
+
+    @Inject(at = @At("RETURN"), method = "<clinit>")
+    private static void lodestone$addTypes(CallbackInfo ci) {
+        RENDER_ORDER = ImmutableList.<ParticleRenderType>builder().addAll(RENDER_ORDER)
+                .add(ParticleMaterials.INSTANCE.getADD(), ParticleMaterials.INSTANCE.getALPHA(), ParticleMaterials.INSTANCE.getBLEND(), ParticleMaterials.INSTANCE.getOPAQUE()).build();
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/PartyScrollMixin.java

@@ -1,53 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.mixin;
-
-import com.cobblemon.mod.common.client.CobblemonClient;
-import com.cobblemon.mod.common.client.keybind.keybinds.PartySendBinding;
-import net.minecraft.client.Mouse;
-import org.objectweb.asm.Opcodes;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(Mouse.class)
-public class PartyScrollMixin {
-    @Shadow
-    private double eventDeltaWheel;
-
-    @Inject(
-            method = "onMouseScroll",
-            at = @At(
-                    value = "FIELD",
-                    target="Lnet/minecraft/client/Mouse;eventDeltaWheel:D",
-                    opcode = Opcodes.PUTFIELD,
-                    ordinal = 2,
-                    shift = At.Shift.BEFORE
-            ),
-            cancellable = true
-    )
-    public void onMouseScroll(long window, double horizontal, double vertical, CallbackInfo ci) {
-        if (PartySendBinding.INSTANCE.getWasDown()) {
-            int i = (int)eventDeltaWheel;
-            if (i > 0) {
-                while (i-- > 0) CobblemonClient.INSTANCE.getStorage().shiftSelected(false);
-                ci.cancel();
-                eventDeltaWheel = 0;
-                PartySendBinding.INSTANCE.actioned();
-            } else if (i < 0) {
-                while (i++ < 0) CobblemonClient.INSTANCE.getStorage().shiftSelected(true);
-                ci.cancel();
-                eventDeltaWheel = 0;
-                PartySendBinding.INSTANCE.actioned();
-            }
-        }
-    }
-}

common/src/main/java/com/cobblemon/mod/common/mixin/PhantomSweepAttackGoalMixin.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.cobblemon.mod.common.pokemon.ai.EntityBehaviour;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.ai.goal.Goal;
+import net.minecraft.world.entity.monster.Phantom;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+
+
+@Mixin(targets = "net.minecraft.world.entity.monster.Phantom$PhantomSweepAttackGoal")
+public abstract class PhantomSweepAttackGoalMixin extends Goal {
+
+    @Unique
+    private Phantom phantomSelf; // Allows access to the outer class
+
+    @Inject(method = "<init>", at = @At("TAIL"))
+    private void onInit(Phantom phantom, CallbackInfo ci) {
+        this.phantomSelf = phantom;
+    }
+
+    @Inject(method = "canContinueToUse", at = @At("RETURN"), cancellable = true)
+    private void modifyCanContinueToUse(CallbackInfoReturnable<Boolean> cir) {
+        Phantom phantom = this.phantomSelf; // Outer class instance
+        if(phantom == null) return;
+
+        if (cir.getReturnValue()) {
+            var nearbyFearedEntities = phantom.level().getEntities(phantom, phantom.getBoundingBox().inflate(16.0),
+                    (entity -> ((entity instanceof PokemonEntity && ((PokemonEntity) entity).getBeamMode() == 0 && ((PokemonEntity) entity).getBehaviour().getEntityInteract().getAvoidedByPhantom())
+                            || (entity instanceof ServerPlayer && EntityBehaviour.Companion.hasPhantomFearedShoulderMount((ServerPlayer)entity)))));
+            if (!nearbyFearedEntities.isEmpty()) {
+               nearbyFearedEntities.forEach(entity -> {
+                   if (entity instanceof PokemonEntity) {
+                       ((PokemonEntity) entity).cry();
+                   }
+                   //TODO: Find a way to make shoulder mounted Pokemon cry
+               });
+                cir.setReturnValue(false);
+            }
+        }
+    }
+}
+

common/src/main/java/com/cobblemon/mod/common/mixin/PiglinBarterMixin.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.CobblemonItems;
+import net.minecraft.world.entity.monster.piglin.PiglinAi;
+import net.minecraft.world.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+
+@Mixin(PiglinAi.class)
+public class PiglinBarterMixin {
+
+    @Inject(method = "isBarterCurrency", at = @At(value = "RETURN"), cancellable = true)
+    private static void cobblemon$acceptsForBarter(ItemStack stack, CallbackInfoReturnable<Boolean> ci) {
+        if (!ci.getReturnValue()) {
+            //TODO: Make a tag?
+            if (stack.is(CobblemonItems.RELIC_COIN_POUCH))
+                ci.setReturnValue(true);
+        }
+    }
+
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/PiglinEntityMixin.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.CobblemonItems;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.monster.piglin.Piglin;
+import net.minecraft.world.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(Piglin.class)
+public abstract class PiglinEntityMixin  {
+    @Inject(method = "holdInOffHand", at = @At(value = "HEAD"), cancellable = true)
+    public void cobblemon$isValidBarteringItem(ItemStack stack, CallbackInfo ci) {
+        Piglin entity = (Piglin)(Object) this;
+        if (stack.is(CobblemonItems.RELIC_COIN_POUCH)) {
+            entity.setItemSlot(EquipmentSlot.OFFHAND, stack);
+            entity.setGuaranteedDrop(EquipmentSlot.OFFHAND);
+            ci.cancel();
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/PlayerAdvancementsMixin.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.platform.events.PlatformEvents;
+import com.cobblemon.mod.common.platform.events.ServerPlayerEvent;
+import net.minecraft.advancements.AdvancementHolder;
+import net.minecraft.server.PlayerAdvancements;
+import net.minecraft.server.level.ServerPlayer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(PlayerAdvancements.class)
+public class PlayerAdvancementsMixin {
+    @Shadow private ServerPlayer player;
+
+    @Inject(method = "award", at = @At(value = "INVOKE", target = "Lnet/minecraft/advancements/AdvancementRewards;grant(Lnet/minecraft/server/level/ServerPlayer;)V"))
+    private void cobblemon$award(AdvancementHolder advancement, String criterionKey, CallbackInfoReturnable<Boolean> cir) {
+        PlatformEvents.SERVER_PLAYER_ADVANCEMENT_EARNED.emit(new ServerPlayerEvent.AdvancementEarned(player, advancement));
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/PlayerMixin.java

@@ -10,86 +10,128 @@ package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.Cobblemon;
 import com.cobblemon.mod.common.CobblemonItems;
+import com.cobblemon.mod.common.OrientationControllable;
 import com.cobblemon.mod.common.api.events.CobblemonEvents;
 import com.cobblemon.mod.common.api.events.item.LeftoversCreatedEvent;
-import com.cobblemon.mod.common.api.storage.NoPokemonStoreException;
+import com.cobblemon.mod.common.api.orientation.OrientationController;
+import com.cobblemon.mod.common.api.pokemon.PokemonSpecies;
 import com.cobblemon.mod.common.api.storage.party.PartyStore;
+import com.cobblemon.mod.common.api.storage.party.PlayerPartyStore;
+import com.cobblemon.mod.common.api.tags.CobblemonItemTags;
+import com.cobblemon.mod.common.duck.PlayerDuck;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.cobblemon.mod.common.pokedex.scanner.PokedexEntityData;
+import com.cobblemon.mod.common.pokedex.scanner.ScannableEntity;
+import com.cobblemon.mod.common.pokemon.FormData;
+import com.cobblemon.mod.common.pokemon.Gender;
 import com.cobblemon.mod.common.pokemon.Pokemon;
+import com.cobblemon.mod.common.pokemon.Species;
 import com.cobblemon.mod.common.util.CompoundTagExtensionsKt;
+import com.cobblemon.mod.common.util.CompoundTagUtilities;
 import com.cobblemon.mod.common.util.DataKeys;
-import net.minecraft.entity.EntityType;
-import net.minecraft.entity.ItemEntity;
-import net.minecraft.entity.LivingEntity;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.item.ItemStack;
-import net.minecraft.item.Items;
-import net.minecraft.nbt.NbtCompound;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.sound.SoundEvent;
-import net.minecraft.sound.SoundEvents;
-import net.minecraft.text.Text;
-import net.minecraft.world.World;
+import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.Tag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.entity.EntityDimensions;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.Pose;
+import net.minecraft.world.entity.item.ItemEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.food.FoodProperties;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Vector3f;
 import org.objectweb.asm.Opcodes;
+import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
-import java.util.Objects;
-import java.util.UUID;
+import java.util.*;
+import java.util.stream.Collectors;
 
-import static com.cobblemon.mod.common.util.LocalizationUtilsKt.lang;
+@Mixin(Player.class)
+public abstract class PlayerMixin extends LivingEntity implements ScannableEntity, OrientationControllable, PlayerDuck {
 
-@Mixin(PlayerEntity.class)
-public abstract class PlayerMixin extends LivingEntity {
+    @Unique
+    private Vector3f cobblemon$driverInput;
+    @Unique
+    private Vector3f cobblemon$lastSentDriverInput;
 
-    @Shadow public abstract NbtCompound getShoulderEntityLeft();
+    @Shadow public abstract CompoundTag getShoulderEntityLeft();
 
-    @Shadow public abstract NbtCompound getShoulderEntityRight();
+    @Shadow public abstract CompoundTag getShoulderEntityRight();
 
-    @Shadow public abstract void dropShoulderEntity(NbtCompound entityNbt);
+    @Shadow public abstract void respawnEntityOnShoulder(CompoundTag entityNbt);
 
-    @Shadow public abstract void setShoulderEntityRight(NbtCompound entityNbt);
+    @Shadow public abstract void setShoulderEntityRight(CompoundTag entityNbt);
 
-    @Shadow public abstract void setShoulderEntityLeft(NbtCompound entityNbt);
+    @Shadow public abstract void setShoulderEntityLeft(CompoundTag entityNbt);
 
     @Shadow public abstract boolean isSpectator();
 
-    @Shadow public abstract boolean giveItemStack(ItemStack stack);
+    @Shadow public abstract boolean addItem(ItemStack stack);
 
-    @Shadow public abstract void sendMessage(Text message, boolean overlay);
+    @Shadow public abstract void displayClientMessage(Component message, boolean overlay);
 
+    @Shadow @Final private static Map<Pose, EntityDimensions> POSES;
+    @Shadow @Final public static EntityDimensions STANDING_DIMENSIONS;
+    @Shadow protected int jumpTriggerTime;
+    @Unique private final OrientationController cobblemon$orientationController = new OrientationController(this);
 
-    protected PlayerMixin(EntityType<? extends LivingEntity> p_20966_, World p_20967_) {
+    protected PlayerMixin(EntityType<? extends LivingEntity> p_20966_, Level p_20967_) {
         super(p_20966_, p_20967_);
     }
 
-    @Inject(method = "dropShoulderEntity", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/EntityType;getEntityFromNbt(Lnet/minecraft/nbt/NbtCompound;Lnet/minecraft/world/World;)Ljava/util/Optional;"), cancellable = true)
-    private void cobblemon$removePokemon(NbtCompound nbt, CallbackInfo ci) {
+    @Inject(method = "respawnEntityOnShoulder", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/EntityType;create(Lnet/minecraft/nbt/CompoundTag;Lnet/minecraft/world/level/Level;)Ljava/util/Optional;"), cancellable = true)
+    private void cobblemon$removePokemon(CompoundTag nbt, CallbackInfo ci) {
         if (CompoundTagExtensionsKt.isPokemonEntity(nbt)) {
-            final UUID uuid = this.getPokemonID(nbt);
-            if (this.isShoulderPokemon(this.getShoulderEntityRight())) {
-                final UUID uuidRight = this.getPokemonID(this.getShoulderEntityRight());
+            final UUID uuid = CompoundTagUtilities.getPokemonID(nbt);
+            if (CompoundTagUtilities.isShoulderPokemon(this.getShoulderEntityRight())) {
+                final UUID uuidRight = CompoundTagUtilities.getPokemonID(this.getShoulderEntityRight());
                 if (uuid.equals(uuidRight)) {
                     this.recallPokemon(uuidRight);
-                    this.setShoulderEntityRight(new NbtCompound());
+                    this.setShoulderEntityRight(new CompoundTag());
                 }
             }
-            if (this.isShoulderPokemon(this.getShoulderEntityLeft())) {
-                final UUID uuidLeft = this.getPokemonID(this.getShoulderEntityLeft());
+            if (CompoundTagUtilities.isShoulderPokemon(this.getShoulderEntityLeft())) {
+                final UUID uuidLeft = CompoundTagUtilities.getPokemonID(this.getShoulderEntityLeft());
                 if (uuid.equals(uuidLeft)) {
                     this.recallPokemon(uuidLeft);
-                    this.setShoulderEntityLeft(new NbtCompound());
+                    this.setShoulderEntityLeft(new CompoundTag());
                 }
             }
             ci.cancel();
         }
     }
 
+    @Inject(method = "tick", at = @At("HEAD"))
+    private void cobblemon$updateRenderOrientation(CallbackInfo ci) {
+        this.cobblemon$orientationController.tick();
+    }
+
+    @Override
+    public EntityDimensions getDefaultDimensions(Pose pose) {
+        if (this.getVehicle() instanceof PokemonEntity) {
+            return STANDING_DIMENSIONS;
+        }
+        return POSES.getOrDefault(pose, STANDING_DIMENSIONS);
+    }
+
     @Inject(
-        method = "dropShoulderEntities",
+        method = "removeEntitiesOnShoulder",
         at = @At(
             value = "JUMP",
             opcode = Opcodes.IFGE,
@@ -100,61 +142,50 @@ public abstract class PlayerMixin extends LivingEntity {
     )
     private void cobblemon$preventPokemonDropping(CallbackInfo ci) {
         // We want to allow both of these to forcefully remove the entities
-        if (this.isSpectator() || this.isDead())
+        if (this.isSpectator() || this.isDeadOrDying())
             return;
-        if (!this.isShoulderPokemon(this.getShoulderEntityLeft())) {
-            this.dropShoulderEntity(this.getShoulderEntityLeft());
-            this.setShoulderEntityLeft(new NbtCompound());
+        if (!CompoundTagUtilities.isShoulderPokemon(this.getShoulderEntityLeft())) {
+            this.respawnEntityOnShoulder(this.getShoulderEntityLeft());
+            this.setShoulderEntityLeft(new CompoundTag());
         }
-        if (!this.isShoulderPokemon(this.getShoulderEntityRight())) {
-            this.dropShoulderEntity(this.getShoulderEntityRight());
-            this.setShoulderEntityRight(new NbtCompound());
+        if (!CompoundTagUtilities.isShoulderPokemon(this.getShoulderEntityRight())) {
+            this.respawnEntityOnShoulder(this.getShoulderEntityRight());
+            this.setShoulderEntityRight(new CompoundTag());
         }
         ci.cancel();
     }
 
-    private UUID getPokemonID(NbtCompound nbt) {
-        return nbt.getCompound(DataKeys.POKEMON)
-                .getUuid(DataKeys.POKEMON_UUID);
-    }
-
     private void recallPokemon(UUID uuid) {
         // We need to do this cause the Entity doesn't store a reference to its storage
-        try {
-            final PartyStore party = Cobblemon.INSTANCE.getStorage().getParty(this.uuid);
-            for (Pokemon pokemon : party) {
-                if (pokemon.getUuid().equals(uuid)) {
-                    pokemon.recall();
-                }
+        final PartyStore party = Cobblemon.INSTANCE.getStorage().getParty(this.getUUID(), this.registryAccess());
+        for (Pokemon pokemon : party) {
+            if (pokemon.getUuid().equals(uuid)) {
+                pokemon.recall();
             }
-        } catch (NoPokemonStoreException ignored) {}
-    }
-
-    private boolean isShoulderPokemon(NbtCompound nbt) {
-        return CompoundTagExtensionsKt.isPokemonEntity(nbt);
+        }
     }
 
     @Inject(
-        method = "eatFood",
+        method = "eat",
         at = @At(
             value = "INVOKE",
-            target = "Lnet/minecraft/entity/player/PlayerEntity;getHungerManager()Lnet/minecraft/entity/player/HungerManager;",
+            target = "Lnet/minecraft/world/entity/player/Player;getFoodData()Lnet/minecraft/world/food/FoodData;",
             shift = At.Shift.AFTER
         )
     )
-    public void onEatFood(World world, ItemStack stack, CallbackInfoReturnable<ItemStack> cir) {
-        if (!getWorld().isClient) {
-            if (stack.getItem() == Items.APPLE && getWorld().random.nextDouble() < Cobblemon.config.getAppleLeftoversChance()) {
+    public void onEatFood(Level world, ItemStack stack, FoodProperties foodComponent, CallbackInfoReturnable<ItemStack> cir) {
+        if (!level().isClientSide) {
+            if (stack.is(CobblemonItemTags.LEAVES_LEFTOVERS) && level().random.nextDouble() < Cobblemon.config.getAppleLeftoversChance()) {
                 ItemStack leftovers = new ItemStack(CobblemonItems.LEFTOVERS);
-                ServerPlayerEntity player = Objects.requireNonNull(getServer()).getPlayerManager().getPlayer(uuid);
+                ServerPlayer player = Objects.requireNonNull(getServer()).getPlayerList().getPlayer(uuid);
                 assert player != null;
                 CobblemonEvents.LEFTOVERS_CREATED.postThen(
                     new LeftoversCreatedEvent(player, leftovers),
                     leftoversCreatedEvent -> null,
                     leftoversCreatedEvent -> {
-                        if(!player.giveItemStack(leftoversCreatedEvent.getLeftovers())) {
-                            var itemPos = player.getRotationVector().multiply(0.5).add(getPos());
-                            getWorld().spawnEntity(new ItemEntity(getWorld(), itemPos.getX(), itemPos.getY(), itemPos.getZ(), leftoversCreatedEvent.getLeftovers()));
+                        if(!player.addItem(leftoversCreatedEvent.getLeftovers())) {
+                            var itemPos = player.getLookAngle().scale(0.5f).add(position());
+                            level().addFreshEntity(new ItemEntity(level(), itemPos.x(), itemPos.y(), itemPos.z(), leftoversCreatedEvent.getLeftovers()));
                         }
                         return null;
                     }
@@ -162,4 +193,118 @@ public abstract class PlayerMixin extends LivingEntity {
             }
         }
     }
-}
+
+    @Inject(method = "isInvulnerableTo", at = @At("HEAD"), cancellable = true)
+    public void isInvulnerableTo(DamageSource source, CallbackInfoReturnable<Boolean> ci) {
+        if (!level().isClientSide && (Object) this instanceof ServerPlayer player) {
+            boolean invulnerableInBattle = this.level().getGameRules().getBoolean(CobblemonGameRules.BATTLE_INVULNERABILITY);
+            boolean inBattle = Cobblemon.INSTANCE.getBattleRegistry().getBattleByParticipatingPlayer(player) != null;
+            if (invulnerableInBattle && inBattle) {
+                ci.setReturnValue(true);
+            }
+        }
+    }
+
+    @Override @Nullable
+    public PokedexEntityData resolvePokemonScan() {
+        if (CompoundTagUtilities.isShoulderPokemon(this.getShoulderEntityRight())){
+            return getDataFromShoulderPokemon(this.getShoulderEntityRight());
+        }
+        if (CompoundTagUtilities.isShoulderPokemon(this.getShoulderEntityLeft())){
+            return getDataFromShoulderPokemon(this.getShoulderEntityLeft());
+        }
+        return null;
+    }
+
+    @Nullable @Unique
+    private PokedexEntityData getDataFromShoulderPokemon(CompoundTag shoulderTag) {
+        CompoundTag pokemonTag = shoulderTag.getCompound(DataKeys.POKEMON);
+        if (pokemonTag.isEmpty()) return null;
+        Species species = PokemonSpecies.INSTANCE.getByIdentifier(ResourceLocation.parse(pokemonTag.getString(DataKeys.POKEMON_SPECIES_IDENTIFIER)));
+        if (species == null) return null;
+        String formId = pokemonTag.getString(DataKeys.POKEMON_FORM_ID);
+        FormData form = species.getStandardForm();
+        List<FormData> formList = species.getForms().stream().filter(it -> it.formOnlyShowdownId().equals(formId)).toList();
+        if (!formList.isEmpty()) form = formList.getFirst();
+        if (form == null) return null;
+        String genderString = pokemonTag.getString(DataKeys.POKEMON_GENDER);
+        if (genderString.isEmpty()) return null;
+        Gender gender = Gender.valueOf(genderString);
+        boolean shiny = pokemonTag.getBoolean(DataKeys.POKEMON_SHINY);
+        int level = pokemonTag.getInt(DataKeys.POKEMON_LEVEL);
+        Set<String> aspects = shoulderTag.getList(DataKeys.SHOULDER_ASPECTS, Tag.TAG_STRING).stream().map(Tag::getAsString).collect(Collectors.toSet());
+
+        Pokemon pokemon = new Pokemon();
+        if (level().isClientSide) {
+            pokemon.setSpecies(species);
+            pokemon.setForm(form);
+            pokemon.setGender(gender);
+            pokemon.setShiny(shiny);
+            pokemon.setLevel(level);
+            pokemon.setForcedAspects(aspects);
+        } else {
+            PlayerPartyStore party = Cobblemon.INSTANCE.getStorage().getParty(this.getUUID(), this.registryAccess());
+            pokemon = party.get(shoulderTag.getUUID(DataKeys.SHOULDER_UUID));
+        }
+        return new PokedexEntityData(pokemon, null);
+    }
+
+    @Override
+    public LivingEntity resolveEntityScan() {
+        return this;
+    }
+
+    @Override
+    public void absMoveTo(double x, double y, double z, float yaw, float pitch) {
+        if (cobblemon$orientationController.getActive()) {
+            this.absMoveTo(x, y, z);
+            this.setYRot(yaw % 360.0f);
+            this.setXRot(pitch % 360.0f);
+            this.yRotO = this.getYRot();
+            this.xRotO = this.getXRot();
+        }
+        else {
+            this.absMoveTo(x, y, z);
+            this.absRotateTo(yaw, pitch);
+        }
+    }
+
+    @WrapOperation(
+            method = "rideTick()V",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/player/Player;wantsToStopRiding()Z")
+    )
+    public boolean delegateDismountToController(Player instance, Operation<Boolean> original) {
+        if (this.getVehicle() instanceof PokemonEntity pokemonEntity) {
+            return pokemonEntity.ifRidingAvailableSupply(false, (behaviour, settings, state) -> {
+                return behaviour.dismountOnShift(settings, state, pokemonEntity) && original.call(instance);
+            });
+        }
+        return original.call(instance);
+    }
+
+    @Override
+    public OrientationController getOrientationController() {
+        return cobblemon$orientationController;
+    }
+
+    @Override
+    public void setDriverInput(Vector3f driverInput) {
+        cobblemon$driverInput = driverInput;
+    }
+
+    @Override
+    public Vector3f getDriverInput() {
+        return cobblemon$driverInput;
+    }
+
+    @Override
+    public void setLastSentDriverInput(Vector3f lastSentDriverInput) {
+        cobblemon$lastSentDriverInput = lastSentDriverInput;
+    }
+
+    @Override
+    public Vector3f getLastSentDriverInput() {
+        return cobblemon$lastSentDriverInput;
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/PointedDripstoneBlockMixin.java

@@ -9,9 +9,9 @@
 package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.api.tags.CobblemonBlockTags;
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.PointedDripstoneBlock;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.PointedDripstoneBlock;
+import net.minecraft.world.level.block.state.BlockState;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Redirect;
@@ -21,12 +21,12 @@ import org.spongepowered.asm.mixin.injection.Slice;
 public abstract class PointedDripstoneBlockMixin {
 
     @Redirect(
-            method = "canGrow(Lnet/minecraft/block/BlockState;Lnet/minecraft/block/BlockState;)Z",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/block/BlockState;isOf(Lnet/minecraft/block/Block;)Z", ordinal = 0),
-            slice = @Slice(from = @At(value = "FIELD", target = "Lnet/minecraft/block/Blocks;DRIPSTONE_BLOCK:Lnet/minecraft/block/Block;"))
+            method = "canGrow(Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/world/level/block/state/BlockState;)Z",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/block/state/BlockState;is(Lnet/minecraft/world/level/block/Block;)Z", ordinal = 0),
+            slice = @Slice(from = @At(value = "FIELD", target = "Lnet/minecraft/world/level/block/Blocks;DRIPSTONE_BLOCK:Lnet/minecraft/world/level/block/Block;"))
     )
     private static boolean cobblemon$validateMoonStoneDripstone(BlockState instance, Block block) {
-        return instance.isIn(CobblemonBlockTags.DRIPSTONE_GROWABLE);
+        return instance.is(CobblemonBlockTags.DRIPSTONE_GROWABLE);
     }
 
 }

common/src/main/java/com/cobblemon/mod/common/mixin/PotionSlotMixin.java

@@ -1,31 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.mixin;
-
-import com.cobblemon.mod.common.brewing.BrewingRecipes;
-import net.minecraft.item.ItemStack;
-import net.minecraft.screen.BrewingStandScreenHandler;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(BrewingStandScreenHandler.PotionSlot.class)
-public class PotionSlotMixin {
-    @Inject(
-        method = "matches",
-        at = @At(value = "HEAD"),
-        cancellable = true
-    )
-    private static void matchesBrewable(ItemStack stack, CallbackInfoReturnable<Boolean> cir) {
-        if (BrewingRecipes.brewableItems.contains(stack.getItem())) {
-            cir.setReturnValue(true);
-        }
-    }
-}

common/src/main/java/com/cobblemon/mod/common/mixin/PowderSnowBlockMixin.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.bedrockk.molang.runtime.value.DoubleValue;
+import com.cobblemon.mod.common.entity.MoLangScriptingEntity;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.block.PowderSnowBlock;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(PowderSnowBlock.class)
+public abstract class PowderSnowBlockMixin {
+    @Inject(method = "canEntityWalkOnPowderSnow", at = @At(value = "RETURN"), cancellable = true)
+    private static void cobblemon$canEntityWalkOnPowderSnow(Entity entity, CallbackInfoReturnable<Boolean> ci) {
+        if (ci.getReturnValue() == false && entity instanceof MoLangScriptingEntity) {
+            ci.setReturnValue(((MoLangScriptingEntity) entity).getConfig().getMap().getOrDefault("can_stand_on_powder_snow", DoubleValue.ZERO).asDouble() == 1.0);
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/RecipeBookSettingsMixin.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import net.minecraft.stats.RecipeBookSettings;
+import net.minecraft.world.inventory.RecipeBookType;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.Map;
+
+@Mixin(RecipeBookSettings.class)
+public class RecipeBookSettingsMixin {
+
+
+    @Shadow @Final public Map<RecipeBookType, RecipeBookSettings.TypeSettings> states;
+
+    @Inject(method = "<init>", at = @At("TAIL"))
+    private void cobblemon$init(CallbackInfo ci) {
+        states.put(RecipeBookType.valueOf("COOKING_POT"), new RecipeBookSettings.TypeSettings(true, true));
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/RecipeBookTypeMixin.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import net.minecraft.world.inventory.RecipeBookType;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.gen.Invoker;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Mixin(value = RecipeBookType.class)
+public class RecipeBookTypeMixin {
+
+    @Final
+    @Mutable
+    @Shadow
+    private static RecipeBookType[] $VALUES; // moj
+
+    @Invoker("<init>")
+    private static RecipeBookType cobblemon$createBookType(String name, int ordinal) {
+        throw new AssertionError();
+    }
+
+    @Inject(
+            method = "<clinit>",
+            at = @At("TAIL")
+    )
+    private static void cobblemon$addRecipeBookType(CallbackInfo ci) {
+        ArrayList<RecipeBookType> types = new ArrayList<>(List.of($VALUES));
+        types.add(cobblemon$createBookType("COOKING_POT", $VALUES.length));
+        $VALUES = types.toArray(RecipeBookType[]::new);
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/ServerEntityMixin.java

@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.CobblemonNetwork;
+import com.cobblemon.mod.common.OrientationControllable;
+import com.cobblemon.mod.common.api.net.NetworkPacket;
+import com.cobblemon.mod.common.api.orientation.OrientationController;
+import com.cobblemon.mod.common.duck.PlayerDuck;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.cobblemon.mod.common.mixin.accessor.ChunkMapAccessor;
+import com.cobblemon.mod.common.mixin.accessor.TrackedEntityAccessor;
+import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateDriverInputPacket;
+import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateOrientationPacket;
+import com.cobblemon.mod.common.net.messages.client.pokemon.update.ClientboundUpdateRidingStatePacket;
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import net.minecraft.network.protocol.Packet;
+import net.minecraft.server.level.ChunkMap;
+import net.minecraft.server.level.ServerEntity;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.network.ServerPlayerConnection;
+import net.minecraft.world.entity.Entity;
+import org.joml.Matrix3f;
+import org.joml.Vector3f;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.Set;
+import java.util.function.Consumer;
+
+@Mixin(ServerEntity.class)
+public abstract class ServerEntityMixin {
+
+    @Shadow
+    @Final
+    private Consumer<Packet<?>> broadcast;
+    @Shadow
+    @Final
+    private Entity entity;
+    @Unique
+    private Matrix3f cobblemon$lastSentOrientation;
+    @Unique
+    private boolean cobblemon$lastSentActive;
+
+    @Inject(method = "sendChanges", at = @At("TAIL"))
+    private void cobblemon$sendChanges(CallbackInfo ci) {
+        cobblemon$sendOrientationChanges();
+        cobblemon$sendRidingStateChanges();
+        cobblemon$sendDriverInput();
+    }
+
+    private void cobblemon$sendRidingStateChanges() {
+        if (!(this.entity instanceof PokemonEntity pokemonEntity)) return;
+        if (pokemonEntity.getRidingController() == null) return;
+        var ridingController = pokemonEntity.getRidingController();
+        if (ridingController.getContext() == null) return;
+        var context = ridingController.getContext();
+        var ridingBehaviour = context.getBehaviour();
+        var ridingState = context.getState();
+        var previousRidingState = pokemonEntity.getPreviousRidingState();
+        if (previousRidingState != null && !ridingState.shouldSync(previousRidingState)) return;
+        cobblemon$broadcast(new ClientboundUpdateRidingStatePacket(pokemonEntity.getId(), ridingBehaviour, ridingState, null));
+    }
+
+    private void cobblemon$sendOrientationChanges() {
+        if (!(this.entity instanceof OrientationControllable controllable)) return;
+        OrientationController controller = controllable.getOrientationController();
+        Matrix3f currOrientation = controller.getOrientation();
+        boolean currActive = controller.getActive();
+
+        if (currOrientation == null || currOrientation.equals(cobblemon$lastSentOrientation) && (currActive == cobblemon$lastSentActive))
+            return;
+        cobblemon$lastSentOrientation = new Matrix3f(currOrientation);
+        cobblemon$lastSentActive = currActive;
+
+        cobblemon$broadcast(new ClientboundUpdateOrientationPacket(currOrientation, currActive, entity.getId()));
+    }
+
+    private void cobblemon$sendDriverInput() {
+        if (!(this.entity instanceof ServerPlayer serverPlayer)) return;
+        if(!(serverPlayer.getVehicle() instanceof PokemonEntity)) return;
+        Vector3f driverInput = ((PlayerDuck)serverPlayer).getDriverInput();
+        if(driverInput == null) return;
+
+        // If no change in input is detected then don't send a new packet
+        Vector3f lastSentDriverInput = ((PlayerDuck)serverPlayer).getLastSentDriverInput();
+        if (driverInput.equals(lastSentDriverInput)) return;
+        ((PlayerDuck)serverPlayer).setLastSentDriverInput(driverInput);
+        cobblemon$broadcast(new ClientboundUpdateDriverInputPacket(driverInput, entity.getId()));
+    }
+
+    private void cobblemon$broadcast(NetworkPacket<?> packet) {
+        if (!(entity.level() instanceof ServerLevel level)) return;
+        ChunkMap chunkMap = level.getChunkSource().chunkMap;
+        Int2ObjectMap<?> entityMap = ((ChunkMapAccessor) chunkMap).getEntityMap();
+        Object tracked = entityMap.get(entity.getId());
+        if (!(tracked instanceof TrackedEntityAccessor tracker)) return;
+
+        Set<ServerPlayerConnection> seenBy = tracker.getSeenBy();
+        for (ServerPlayerConnection conn : seenBy) {
+            ServerPlayer player = conn.getPlayer();
+            if (player == entity) continue;
+            CobblemonNetwork.INSTANCE.sendPacketToPlayer(player, packet);
+        }
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/ServerLevelMixin.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.phys.AABB;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.List;
+import java.util.Optional;
+
+
+@Mixin(ServerLevel.class)
+public abstract class ServerLevelMixin {
+
+    @Inject(method = "findLightningRod", at = @At(value = "RETURN"), cancellable = true)
+    private void cobblemon$findLightningRod(BlockPos blockPos, CallbackInfoReturnable<Optional<BlockPos>> ci) {
+        final ServerLevel serverLevel = (ServerLevel) (Object) this;
+        if (ci.getReturnValue().isEmpty()) {
+            // Search for Pokemon with the ability Lightning Rod and redirect to them
+            AABB aABB = AABB.encapsulatingFullBlocks(blockPos, new BlockPos(blockPos.atY(serverLevel.getMaxBuildHeight()))).inflate(64.0);
+            List<LivingEntity> list = serverLevel.getEntitiesOfClass(LivingEntity.class, aABB, (livingEntity) -> livingEntity != null
+                    && livingEntity.isAlive()
+                    && livingEntity instanceof PokemonEntity
+                    && ((PokemonEntity) livingEntity).getBeamMode() == 0
+                    && ((PokemonEntity) livingEntity).getPokemon().getAbility().getName().equals("lightningrod"));
+            if (!list.isEmpty()) {
+                ci.setReturnValue(Optional.of((list.get(serverLevel.random.nextInt(list.size()))).blockPosition()));
+            }
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/ServerPlayerMixin.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.OrientationControllable;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.llamalad7.mixinextras.sugar.Local;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Entity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ServerPlayer.class)
+public abstract class ServerPlayerMixin {
+
+    @Inject(method = "rideTick", at = @At("HEAD"))
+    private void cobblemon$updateOrientationControllerRideTick(CallbackInfo ci) {
+        if (!(this instanceof OrientationControllable controllable)) return;
+        var shouldUseCustomOrientation = cobblemon$shouldUseCustomOrientation((ServerPlayer)(Object)this);
+        controllable.getOrientationController().setActive(shouldUseCustomOrientation);
+    }
+
+    @Unique
+    private boolean cobblemon$shouldUseCustomOrientation(ServerPlayer player) {
+        var playerVehicle = player.getVehicle();
+        if (playerVehicle == null) return false;
+        if (!(playerVehicle instanceof PokemonEntity pokemonEntity)) return false;
+        return pokemonEntity.ifRidingAvailableSupply(false, (behaviour, settings, state) -> {
+            return behaviour.shouldRoll(settings, state, pokemonEntity);
+        });
+    }
+
+    @Inject(method = "stopRiding", at = @At("HEAD"))
+    public void cobblemon$resetOrientationOnDismount(CallbackInfo ci) {
+        if (!(this instanceof OrientationControllable controllable)) return;
+        controllable.getOrientationController().setActive(false);
+    }
+
+    //TODO: Switch to sending out on load instead of preventing saving
+    @ModifyExpressionValue(method = "addAdditionalSaveData", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/Entity;hasExactlyOnePlayerPassenger()Z"))
+    private boolean cobblemon$cancelSavingPokemonMounts(boolean original, @Local(ordinal=0) Entity entity) {
+        return original && !(entity instanceof PokemonEntity);
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/ShearsDispenserBehaviorMixin.java

@@ -10,21 +10,21 @@ package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.block.ShearableBlock;
 import kotlin.Unit;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.dispenser.ShearsDispenserBehavior;
-import net.minecraft.server.world.ServerWorld;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.dispenser.ShearsDispenseItemBehavior;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.block.state.BlockState;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
-@Mixin(ShearsDispenserBehavior.class)
+@Mixin(ShearsDispenseItemBehavior.class)
 public abstract class ShearsDispenserBehaviorMixin {
 
     // This exists, so we can execute our custom interaction only if no one redirected shears interactions to overwrite the vanilla ones.
-    @Inject(method = "tryShearBlock", at = @At("HEAD"), cancellable = true)
-    private static void cobblemon$tryApricornHarvest(ServerWorld world, BlockPos pos, CallbackInfoReturnable<Boolean> cir) {
+    @Inject(method = "tryShearBeehive", at = @At("HEAD"), cancellable = true)
+    private static void cobblemon$tryApricornHarvest(ServerLevel world, BlockPos pos, CallbackInfoReturnable<Boolean> cir) {
         final BlockState state = world.getBlockState(pos);
         if (state.getBlock() instanceof ShearableBlock shearableBlock) {
             cir.setReturnValue(shearableBlock.attemptShear(world, state, pos, () -> Unit.INSTANCE));

common/src/main/java/com/cobblemon/mod/common/mixin/SimpleBlockFeatureMixin.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.block.HeartyGrainsBlock;
+import com.llamalad7.mixinextras.sugar.Local;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.DoublePlantBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.DoubleBlockHalf;
+import net.minecraft.world.level.levelgen.feature.FeaturePlaceContext;
+import net.minecraft.world.level.levelgen.feature.SimpleBlockFeature;
+import net.minecraft.world.level.levelgen.feature.configurations.SimpleBlockConfiguration;
+import org.spongepowered.asm.mixin.Debug;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(SimpleBlockFeature.class)
+@Debug(export = true, print = true)
+public class SimpleBlockFeatureMixin {
+    //this mixin inserts the logic needed to ensure that when hearty grains are of a certain age, they place with the upper block too
+    //similarly to what the doubleblock logic is here
+    @Inject(method = "place", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/block/state/BlockState;canSurvive(Lnet/minecraft/world/level/LevelReader;Lnet/minecraft/core/BlockPos;)Z", shift = At.Shift.AFTER), cancellable = true)
+    public void place(FeaturePlaceContext<SimpleBlockConfiguration> context, CallbackInfoReturnable<Boolean> cir,
+                      @Local BlockState blockState, @Local BlockPos blockPos, @Local WorldGenLevel worldGenLevel) {
+        if (!(blockState.getBlock() instanceof HeartyGrainsBlock)) {
+            return;
+        }
+        if (blockState.getValue(HeartyGrainsBlock.Companion.getAGE()) <= HeartyGrainsBlock.AGE_AFTER_HARVEST) {
+            return; //block is too young to be double
+        }
+        if (!worldGenLevel.isEmptyBlock(blockPos.above())) {
+            cir.setReturnValue(false); //no space for the 2nd block above
+            return;
+        }
+        DoublePlantBlock.placeAt(worldGenLevel, blockState, blockPos, Block.UPDATE_CLIENTS);
+        cir.setReturnValue(true);
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/SoundEngineMixin.java

@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.api.riding.sound.RideAttenuationModel;
+import com.cobblemon.mod.common.api.riding.sound.RideLoopSound;
+import com.cobblemon.mod.common.client.sound.BattleMusicController;
+import com.cobblemon.mod.common.duck.ChannelDuck;
+import com.cobblemon.mod.common.duck.SoundEngineDuck;
+import com.google.common.collect.Multimap;
+import com.llamalad7.mixinextras.sugar.Local;
+import com.mojang.blaze3d.audio.Channel;
+import net.minecraft.client.resources.sounds.Sound;
+import net.minecraft.client.resources.sounds.SoundInstance;
+import net.minecraft.client.resources.sounds.TickableSoundInstance;
+import net.minecraft.client.sounds.ChannelAccess;
+import net.minecraft.client.sounds.SoundEngine;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+
+import java.util.Iterator;
+import java.util.Map;
+
+@Mixin(SoundEngine.class)
+public abstract class SoundEngineMixin implements SoundEngineDuck {
+
+    @Shadow
+    private boolean loaded;
+
+    @Shadow
+    private Multimap<SoundSource, SoundInstance> instanceBySource;
+
+    @Shadow @Final
+    private Map<SoundInstance, ChannelAccess.ChannelHandle> instanceToChannel;
+
+    @Shadow
+    protected abstract void stop(SoundInstance sound);
+
+    @Shadow
+    public abstract boolean isActive(SoundInstance sound);
+
+    @Inject(method = "play",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/client/sounds/ChannelAccess$ChannelHandle;execute(Ljava/util/function/Consumer;)V"
+            ),
+            cancellable = true
+    )
+    private void cobblemon$overrideChannelExecute(
+            SoundInstance sound,
+            CallbackInfo ci,
+            @Local(name = "h") float h,
+            @Local(name = "i") float i,
+            @Local(name = "g") float g,
+            @Local(name = "bl2") boolean bl2,
+            @Local(name = "bl3") boolean bl3,
+            @Local(name = "bl") boolean bl,
+            @Local(name = "vec3") Vec3 vec3,
+            @Local(name = "channelHandle") ChannelAccess.ChannelHandle handle
+    ) {
+        if (!(sound instanceof RideLoopSound rideSound)) return;
+
+        if (handle == null) return;
+
+        handle.execute((channel) -> {
+            channel.setPitch(i);
+            channel.setVolume(h);
+
+            if (rideSound.getRideAttenuation() == RideAttenuationModel.LINEAR) {
+                channel.linearAttenuation(g);
+            } else if (rideSound.getRideAttenuation() == RideAttenuationModel.EXPONENTIAL){
+                ((ChannelDuck) channel).cobblemon$inverseAttenuation(g);
+            } else {
+                channel.disableAttenuation();
+            }
+
+            // Apply low pass filter if the rideSound dictate that it should be muffled
+            if (rideSound.getShouldMuffle()) {
+                ((ChannelDuck) channel).cobblemon$applyLowPassFilter(1.0f, rideSound.getMuffleAmount());
+            } else {
+                ((ChannelDuck) channel).cobblemon$clearFilters();
+            }
+
+            channel.setLooping(bl2 && !bl3);
+            channel.setSelfPosition(vec3);
+            channel.setRelative(bl);
+        });
+    }
+
+    @Inject(
+            method = "tickNonPaused",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/client/sounds/ChannelAccess$ChannelHandle;execute(Ljava/util/function/Consumer;)V",
+                    ordinal = 0
+            )
+    )
+    private void cobblemon$tickableSoundTick(
+            CallbackInfo ci,
+            @Local(name = "tickableSoundInstance") TickableSoundInstance instance,
+            @Local(name = "channelHandle", ordinal = 0) ChannelAccess.ChannelHandle handle,
+            @Local(name = "f", ordinal = 0) float volume,
+            @Local(name = "g", ordinal = 0) float pitch,
+            @Local(name = "vec3", ordinal = 0) Vec3 vec3
+    ) {
+        if (!(instance instanceof RideLoopSound rideSound)) return;
+
+        handle.execute(channel -> {
+            channel.setVolume(volume);
+            channel.setPitch(pitch);
+            channel.setSelfPosition(vec3);
+
+            // Apply low pass filter if the rideSound dictate that it should be muffled
+            if (rideSound.getShouldMuffle()) {
+                ((ChannelDuck) channel).cobblemon$applyLowPassFilter(1.0f, rideSound.getMuffleAmount());
+            } else {
+                ((ChannelDuck) channel).cobblemon$clearFilters();
+            }
+        });
+    }
+
+    /** Resumes the Source belonging to the queried SoundInstance. */
+    private void resume(SoundInstance sound) {
+        ChannelAccess.ChannelHandle sourceManager = this.instanceToChannel.get(sound);
+        if (this.loaded && sourceManager != null) sourceManager.execute(Channel::unpause);
+    }
+
+    /** Pauses the Source belonging to the queried SoundInstance. */
+    private void pause(SoundInstance sound) {
+        ChannelAccess.ChannelHandle sourceManager = this.instanceToChannel.get(sound);
+        if (this.loaded && sourceManager != null) sourceManager.execute(Channel::pause);
+    }
+
+    /** Resumes the SoundInstance(s) queried by id and/or category. */
+    @Override
+    public void resumeSounds(@Nullable ResourceLocation id, @Nullable SoundSource category) {
+        if (category != null) {
+            this.instanceBySource.get(category).forEach((sound) -> {
+                if (id == null || sound.getLocation().equals(id)) resume(sound);
+            });
+        } else if (id == null) {
+            this.instanceToChannel.keySet().forEach(this::resume);
+        } else {
+            this.instanceToChannel.keySet().forEach(sound -> {
+                if (sound.getLocation().equals(id)) resume(sound);
+            });
+        }
+    }
+
+    /** Pauses the SoundInstances queried by id and/or category. */
+    @Override
+    public void pauseSounds(@Nullable ResourceLocation id, @Nullable SoundSource category) {
+        if (category != null) {
+            this.instanceBySource.get(category).forEach((sound) -> {
+                if (id == null || sound.getLocation().equals(id)) pause(sound);
+            });
+        } else if (id == null) {
+            this.instanceToChannel.keySet().forEach(this::pause);
+        } else {
+            this.instanceToChannel.keySet().forEach(sound -> {
+                if (sound.getLocation().equals(id)) pause(sound);
+            });
+        }
+    }
+
+    /** Allows stopping all SoundInstances that belong to a queried category. */
+    @Inject(method = "stop(Lnet/minecraft/resources/ResourceLocation;Lnet/minecraft/sounds/SoundSource;)V", at = @At("HEAD"), cancellable = true)
+    public void stopSounds(@Nullable ResourceLocation id, @Nullable SoundSource category, CallbackInfo cb) {
+        if (id == null && category != null) {
+            this.instanceBySource.get(category).forEach(this::stop);
+            cb.cancel();
+        }
+    }
+
+    /** Different behavior for resuming SoundInstances while a BattleMusicInstance is being played. We do not want to resume filtered sounds. */
+    @Inject(method = "resume()V", at = @At("HEAD"), cancellable = true)
+    public void resume(CallbackInfo cb) {
+        if (this.isActive(BattleMusicController.INSTANCE.getMusic())) {
+            this.instanceBySource.values().forEach(sound -> {
+               if (sound == BattleMusicController.INSTANCE.getMusic() || !BattleMusicController.INSTANCE.getFilteredCategories().contains(sound.getSource())) {
+                   resume(sound);
+               }
+            });
+            cb.cancel();
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/SoundManagerMixin.java

@@ -8,36 +8,88 @@
 
 package com.cobblemon.mod.common.mixin;
 
-import com.cobblemon.mod.common.access.SoundManagerDuck;
-import net.minecraft.client.sound.SoundInstance;
-import net.minecraft.client.sound.SoundManager;
-import net.minecraft.sound.SoundCategory;
+import com.cobblemon.mod.common.client.sound.BattleMusicController;
+import com.cobblemon.mod.common.client.sound.SoundTracker;
+import com.cobblemon.mod.common.duck.SoundEngineDuck;
+import com.cobblemon.mod.common.duck.SoundManagerDuck;
+import net.minecraft.client.resources.sounds.BiomeAmbientSoundsHandler;
+import net.minecraft.client.resources.sounds.SoundInstance;
+import net.minecraft.client.resources.sounds.UnderwaterAmbientSoundInstances;
+import net.minecraft.client.sounds.SoundEngine;
+import net.minecraft.client.sounds.SoundManager;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.sounds.SoundSource;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(SoundManager.class)
-public class SoundManagerMixin implements SoundManagerDuck {
+public abstract class SoundManagerMixin implements SoundManagerDuck {
 
-    private boolean[] blockedCategories = new boolean[SoundCategory.values().length];
+    @Shadow
+    public abstract boolean isActive(SoundInstance sound);
 
+    @Shadow @Final
+    private SoundEngine soundEngine;
+
+    // Never-ending ambient loops are a special exception (they are only initiated once) and should always be paused if filtered.
+    private boolean isAmbientLoop(SoundInstance sound) {
+        return sound instanceof BiomeAmbientSoundsHandler.LoopSoundInstance || sound instanceof UnderwaterAmbientSoundInstances.UnderwaterAmbientSoundInstance;
+    }
+
+    private boolean filterCondition(SoundInstance sound) {
+        return !isAmbientLoop(sound) &&
+            this.isActive(BattleMusicController.INSTANCE.getMusic()) &&
+                BattleMusicController.INSTANCE.getFilteredCategories().contains(sound.getSource());
+    }
+
+    private boolean ambientLoopCondition(SoundInstance sound) {
+        return isAmbientLoop(sound) &&
+            this.isActive(BattleMusicController.INSTANCE.getMusic()) &&
+                BattleMusicController.INSTANCE.getFilteredCategories().contains(sound.getSource());
+    }
+
+    /** Pauses the queried SoundInstance(s). If id is null, will pause all sounds belonging to the SoundCategory. */
     @Override
-    public void toggleCategories(SoundCategory... categories) {
-        for (SoundCategory category : categories) {
-            int index = category.ordinal();
-            boolean blocked = blockedCategories[index];
-            blockedCategories[index] = !blocked;
-        }
+    public void pauseSounds(@Nullable ResourceLocation id, @Nullable SoundSource category) {
+        ((SoundEngineDuck)soundEngine).pauseSounds(id, category);
     }
 
-    @Inject(method = "play(Lnet/minecraft/client/sound/SoundInstance;)V", at = @At("HEAD"), cancellable = true)
-    public void play(SoundInstance sound, CallbackInfo cb) {
-        if (blockedCategories[sound.getCategory().ordinal()]) cb.cancel();
+    /** Resumes the queried SoundInstance(s). If id is null, will resume all sounds belonging to the SoundCategory. */
+    @Override
+    public void resumeSounds(@Nullable ResourceLocation id, @Nullable SoundSource category) {
+        ((SoundEngineDuck)soundEngine).resumeSounds(id, category);
     }
 
-    @Inject(method = "play(Lnet/minecraft/client/sound/SoundInstance;I)V", at = @At("HEAD"), cancellable = true)
-    public void play(SoundInstance sound, int delay, CallbackInfo cb) {
-        if (blockedCategories[sound.getCategory().ordinal()]) cb.cancel();
+    /** Blocks filtered sounds from being played while a BattleMusicInstance is in progress. */
+    @Inject(method = "play(Lnet/minecraft/client/resources/sounds/SoundInstance;)V", at = @At("HEAD"), cancellable = true)
+    public void playStart(SoundInstance sound, CallbackInfo cb) {
+        if (filterCondition(sound)) cb.cancel();
+    }
+
+    @Inject(method = "playDelayed(Lnet/minecraft/client/resources/sounds/SoundInstance;I)V", at = @At("HEAD"), cancellable = true)
+    public void playStart(SoundInstance sound, int delay, CallbackInfo cb) {
+        if (filterCondition(sound)) cb.cancel();
+    }
+
+    /** Pauses ambient loops while a BattleMusicInstance is in progress. */
+    @Inject(method = "play(Lnet/minecraft/client/resources/sounds/SoundInstance;)V", at = @At("TAIL"))
+    public void playEnd(SoundInstance sound, CallbackInfo cb) {
+        if (ambientLoopCondition(sound)) this.pauseSounds(sound.getLocation(), SoundSource.AMBIENT);
+    }
+
+    @Inject(method = "playDelayed(Lnet/minecraft/client/resources/sounds/SoundInstance;I)V", at = @At("TAIL"))
+    public void playEnd(SoundInstance sound, int delay, CallbackInfo cb) {
+        if (ambientLoopCondition(sound)) this.pauseSounds(sound.getLocation(), SoundSource.AMBIENT);
+    }
+
+    /** Clears tracked sounds on the client when disconnected. */
+    @Inject(method = "stop()V", at = @At("TAIL"))
+    public void stop(CallbackInfo cb) {
+        SoundTracker.Companion.clear();
     }
 }

common/src/main/java/com/cobblemon/mod/common/mixin/SoundSystemMixin.java

@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.mixin;
-
-import com.google.common.collect.Multimap;
-import net.minecraft.client.sound.SoundInstance;
-import net.minecraft.client.sound.SoundSystem;
-import net.minecraft.sound.SoundCategory;
-import net.minecraft.util.Identifier;
-import org.jetbrains.annotations.Nullable;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(SoundSystem.class)
-public abstract class SoundSystemMixin {
-
-    @Shadow
-    private Multimap<SoundCategory, SoundInstance> sounds;
-
-    @Shadow
-    protected abstract void stop(SoundInstance sound);
-
-    @Inject(method = "stopSounds(Lnet/minecraft/util/Identifier;Lnet/minecraft/sound/SoundCategory;)V", at = @At("HEAD"), cancellable = true)
-    public void stopSounds(@Nullable Identifier id, @Nullable SoundCategory category, CallbackInfo cb) {
-        if (id == null && category != null) {
-            sounds.get(category).forEach(this::stop);
-            cb.cancel();
-        }
-    }
-}

common/src/main/java/com/cobblemon/mod/common/mixin/StructureMixin.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.world.CobblemonStructureIDs;
+import com.llamalad7.mixinextras.sugar.Local;
+import net.minecraft.core.Holder;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.LevelHeightAccessor;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.biome.BiomeSource;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.RandomState;
+import net.minecraft.world.level.levelgen.structure.Structure;
+import net.minecraft.world.level.levelgen.structure.StructurePiece;
+import net.minecraft.world.level.levelgen.structure.StructureStart;
+import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplateManager;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.Predicate;
+
+@Mixin(Structure.class)
+public abstract class StructureMixin {
+    // Define a set of structures that should not spawn below Sea Level
+    @Unique
+    private static final Set<ResourceLocation> RESTRICTED_STRUCTURES = new HashSet<>(Arrays.asList(
+            CobblemonStructureIDs.STONJOURNER_HENGE,
+            CobblemonStructureIDs.LUNA_HENGE,
+            CobblemonStructureIDs.SOL_HENGE
+    ));
+
+    @Inject(method = "generate", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/levelgen/structure/StructureStart;isValid()Z"),
+            cancellable = true)
+    public void cobblemon$isValid(RegistryAccess registryAccess, ChunkGenerator chunkGenerator, BiomeSource biomeSource,
+                                  RandomState randomState, StructureTemplateManager structureTemplateManager, long seed,
+                                  ChunkPos chunkPos, int references, LevelHeightAccessor heightAccessor,
+                                  Predicate<Holder<Biome>> validBiome,
+                                  CallbackInfoReturnable<StructureStart> cir,
+                                  @Local StructureStart structureStart) {
+        ResourceLocation structureKey = registryAccess.registryOrThrow(Registries.STRUCTURE).getKey((Structure) (Object) this);
+        if(!RESTRICTED_STRUCTURES.contains(structureKey)) {
+            return;
+        }
+        for (StructurePiece piece : structureStart.getPieces()) {
+            if (piece.getBoundingBox().minY() < chunkGenerator.getSeaLevel()) {
+                cir.setReturnValue(StructureStart.INVALID_START);
+                return;
+            }
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/StructurePoolAccessor.java

@@ -10,23 +10,23 @@ package com.cobblemon.mod.common.mixin;
 
 import com.mojang.datafixers.util.Pair;
 import it.unimi.dsi.fastutil.objects.ObjectArrayList;
-import net.minecraft.structure.pool.StructurePool;
-import net.minecraft.structure.pool.StructurePoolElement;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Mutable;
 import org.spongepowered.asm.mixin.gen.Accessor;
 
 import java.util.List;
+import net.minecraft.world.level.levelgen.structure.pools.StructurePoolElement;
+import net.minecraft.world.level.levelgen.structure.pools.StructureTemplatePool;
 
-@Mixin(StructurePool.class)
+@Mixin(StructureTemplatePool.class)
 public interface StructurePoolAccessor {
-    @Accessor("elementCounts")
+    @Accessor("rawTemplates")
     List<Pair<StructurePoolElement, Integer>> getElementCounts();
 
     @Mutable
-    @Accessor("elementCounts")
+    @Accessor("rawTemplates")
     void setElementCounts(List<Pair<StructurePoolElement, Integer>> elementCounts);
 
-    @Accessor("elements")
+    @Accessor("templates")
     ObjectArrayList<StructurePoolElement> getElements();
 }

common/src/main/java/com/cobblemon/mod/common/mixin/StructurePoolGeneratorMixin.java

@@ -9,47 +9,45 @@
 package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.world.CobblemonStructureIDs;
-import net.minecraft.registry.Registry;
-import net.minecraft.structure.PoolStructurePiece;
-import net.minecraft.structure.StructureTemplateManager;
-import net.minecraft.structure.pool.*;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.math.random.Random;
-import net.minecraft.util.shape.VoxelShape;
-import net.minecraft.world.HeightLimitView;
-import net.minecraft.world.gen.chunk.ChunkGenerator;
-import net.minecraft.world.gen.noise.NoiseConfig;
+import com.llamalad7.mixinextras.sugar.Local;
+import net.minecraft.core.Registry;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.LevelHeightAccessor;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.RandomState;
+import net.minecraft.world.level.levelgen.structure.PoolElementStructurePiece;
+import net.minecraft.world.level.levelgen.structure.pools.*;
+import net.minecraft.world.level.levelgen.structure.pools.alias.PoolAliasLookup;
+import net.minecraft.world.level.levelgen.structure.templatesystem.LiquidSettings;
+import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplateManager;
+import net.minecraft.world.phys.shapes.VoxelShape;
 import org.apache.commons.lang3.mutable.MutableObject;
-import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Mutable;
-import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.ModifyVariable;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 
 import java.util.*;
 
-@Mixin(StructurePoolBasedGenerator.StructurePoolGenerator.class)
+@Mixin(JigsawPlacement.Placer.class)
 public abstract class StructurePoolGeneratorMixin {
-    @Final
-    @Mutable
-    @Shadow Deque<StructurePoolBasedGenerator.ShapedPoolStructurePiece> structurePieces;
 
     Map<String, Integer> generatedStructureGroupCounts;
 
     private static final Map<String, Integer> structureMaxes;
-    private static final Map<Identifier, Set<String>> structureGroups = new HashMap<>();
+    private static final Map<ResourceLocation, Set<String>> structureGroups = new HashMap<>();
     static {
         String pokecenter = "pokecenter";
         String berry = "berry_farm";
 
-        structureGroups.put(CobblemonStructureIDs.PLAINS_POKECENTER, Set.of(pokecenter));
-        structureGroups.put(CobblemonStructureIDs.DESERT_POKECENTER, Set.of(pokecenter));
-        structureGroups.put(CobblemonStructureIDs.SAVANNA_POKECENTER, Set.of(pokecenter));
-        structureGroups.put(CobblemonStructureIDs.SNOWY_POKECENTER, Set.of(pokecenter));
-        structureGroups.put(CobblemonStructureIDs.TAIGA_POKECENTER, Set.of(pokecenter));
+        structureGroups.put(CobblemonStructureIDs.VILLAGE_PLAINS_POKECENTER, Set.of(pokecenter));
+        structureGroups.put(CobblemonStructureIDs.VILLAGE_DESERT_POKECENTER, Set.of(pokecenter));
+        structureGroups.put(CobblemonStructureIDs.VILLAGE_SAVANNA_POKECENTER, Set.of(pokecenter));
+        structureGroups.put(CobblemonStructureIDs.VILLAGE_SNOWY_POKECENTER, Set.of(pokecenter));
+        structureGroups.put(CobblemonStructureIDs.VILLAGE_TAIGA_POKECENTER, Set.of(pokecenter));
 
         structureGroups.put(CobblemonStructureIDs.SAVANNA_BERRY_SMALL, Set.of(berry));
         structureGroups.put(CobblemonStructureIDs.SAVANNA_BERRY_LARGE, Set.of(berry));
@@ -75,11 +73,11 @@ public abstract class StructurePoolGeneratorMixin {
         structureMaxes = Collections.unmodifiableMap(aMap);
     }
 
-    public Set<String> getGroups(Identifier structureIdentifier) {
+    public Set<String> getGroups(ResourceLocation structureIdentifier) {
         return structureGroups.getOrDefault(structureIdentifier, Set.of());
     }
 
-    public boolean hasReachedMaximum(Identifier structureIdentifier) {
+    public boolean hasReachedMaximum(ResourceLocation structureIdentifier) {
         Set<String> groups = getGroups(structureIdentifier);
         for (String group : groups) {
             int count = generatedStructureGroupCounts.getOrDefault(group, 0);
@@ -91,7 +89,7 @@ public abstract class StructurePoolGeneratorMixin {
         return false;
     }
 
-    public void incrementStructureCount(Identifier structureIdentifier) {
+    public void incrementStructureCount(ResourceLocation structureIdentifier) {
         Set<String> groups = getGroups(structureIdentifier);
         for (String group : groups) {
             generatedStructureGroupCounts.put(group, generatedStructureGroupCounts.getOrDefault(group, 0) + 1);
@@ -99,17 +97,17 @@ public abstract class StructurePoolGeneratorMixin {
     }
 
     @Inject(method = "<init>", at = @At("RETURN"))
-    private void onStructurePoolGeneratorCreation(Registry<StructurePool> registry, int maxSize, ChunkGenerator chunkGenerator, StructureTemplateManager structureTemplateManager, List<? super PoolStructurePiece> children, Random random, CallbackInfo ci) {
+    private void onStructurePoolGeneratorCreation(Registry<StructureTemplatePool> registry, int maxSize, ChunkGenerator chunkGenerator, StructureTemplateManager structureTemplateManager, List<? super PoolElementStructurePiece> children, RandomSource random, CallbackInfo ci) {
         generatedStructureGroupCounts = new HashMap<>();
     }
 
-    @ModifyVariable(method = "generatePiece", at = @At("STORE"), ordinal = 1)
+    @ModifyVariable(method = "tryPlacingChildren", at = @At("STORE"), ordinal = 1)
     private Iterator<StructurePoolElement> reduceStructurePoolElementIterator(Iterator<StructurePoolElement> iterator) {
         List<StructurePoolElement> reducedList = new ArrayList<>();
 
         while (iterator.hasNext()) {
             StructurePoolElement structure = iterator.next();
-            Identifier structurePieceLocationKey = getCobblemonOnlyLocation(structure);
+            ResourceLocation structurePieceLocationKey = getCobblemonOnlyLocation(structure);
             if (structurePieceLocationKey == null) {
                 reducedList.add(structure);
                 continue;
@@ -123,55 +121,27 @@ public abstract class StructurePoolGeneratorMixin {
         return reducedList.iterator();
     }
 
-    @ModifyVariable(method = "generatePiece", at = @At("STORE"), ordinal = 1)
-    private PoolStructurePiece injected(PoolStructurePiece poolStructurePiece) {
-        Identifier structureLocationKey = getCobblemonOnlyLocation(poolStructurePiece.getPoolElement());
+    @Inject(method = "tryPlacingChildren", at = @At(value = "NEW", target = "net/minecraft/world/level/levelgen/structure/PoolElementStructurePiece", ordinal = 0), locals = LocalCapture.CAPTURE_FAILHARD)
+    private void afterTryPlacingChildren(
+        PoolElementStructurePiece poolElementStructurePiece,
+        MutableObject<VoxelShape> mutableObject,
+        int i,
+        boolean bl,
+        LevelHeightAccessor levelHeightAccessor,
+        RandomState randomState,
+        PoolAliasLookup poolAliasLookup,
+        LiquidSettings liquidSettings,
+        CallbackInfo ci,
+        @Local(ordinal = 1) StructurePoolElement structurePoolElement
+    ) {
+        ResourceLocation structureLocationKey = getCobblemonOnlyLocation(structurePoolElement);
         if (structureLocationKey != null) {
             incrementStructureCount(structureLocationKey);
         }
-        return poolStructurePiece;
     }
 
-    // This doesn't SEEM necessary? It appears to work without.
-    @Inject(method = "generatePiece", at = @At("HEAD"))
-    private void beforeGeneratePiece(PoolStructurePiece piece, MutableObject<VoxelShape> pieceShape, int minY, boolean modifyBoundingBox, HeightLimitView world, NoiseConfig noiseConfig, CallbackInfo ci) {
-//        Identifier structureLocationKey = getCobblemonOnlyLocation(piece.getPoolElement());
-//
-//        if (structureLocationKey != null) {
-//            Integer currentlyGenerated = generatedStructureCounts.get(structureLocationKey);
-//            if (currentlyGenerated == null) currentlyGenerated = 0;
-//            generatedStructureCounts.put(structureLocationKey, currentlyGenerated + 1);
-//        }
-//
-//        List<StructurePoolBasedGenerator.ShapedPoolStructurePiece> reducedStructurePiecesList = structurePieces.stream().toList();
-//
-//        for (Identifier maxStructureLocationKey : structureMaxes.keySet()) {
-//            Integer maxAllowed = structureMaxes.get(maxStructureLocationKey);
-//
-//            Integer currentlyGenerated = generatedStructureCounts.get(maxStructureLocationKey);
-//            if (currentlyGenerated == null) currentlyGenerated = 0;
-//            if (currentlyGenerated < maxAllowed) {
-//                continue;
-//            }
-//
-//            //Already have max so need to remove
-//            reducedStructurePiecesList = reducedStructurePiecesList.stream()
-//                    .filter(shapedStructurePiece -> {
-//                        Identifier locationKey = getCobblemonOnlyLocation(shapedStructurePiece.piece.getPoolElement());
-//                        if (locationKey == null) {
-//                            return true;
-//                        }
-//
-//                        return !locationKey.equals(maxStructureLocationKey);
-//                    })
-//                    .collect(Collectors.toList());
-//        }
-//
-//        structurePieces = new ArrayDeque<>(reducedStructurePiecesList);
-    }
-
-    private static Identifier getCobblemonOnlyLocation(StructurePoolElement structurePoolElement) {
-        Identifier location = getLocationIfAvailable(structurePoolElement);
+    private static ResourceLocation getCobblemonOnlyLocation(StructurePoolElement structurePoolElement) {
+        ResourceLocation location = getLocationIfAvailable(structurePoolElement);
         if (location == null) return null;
 
         if (!location.getNamespace().equals("cobblemon")) return null;
@@ -179,39 +149,17 @@ public abstract class StructurePoolGeneratorMixin {
         return location;
     }
 
-    private static Identifier getLocationIfAvailable(StructurePoolElement structurePoolElement) {
+    private static ResourceLocation getLocationIfAvailable(StructurePoolElement structurePoolElement) {
         if (structurePoolElement instanceof LegacySinglePoolElement legacySinglePoolElement) {
-            if (legacySinglePoolElement.location.left().isEmpty()) return null;
+            if (legacySinglePoolElement.template.left().isEmpty()) return null;
 
-            return legacySinglePoolElement.location.left().get();
+            return legacySinglePoolElement.template.left().get();
         } else if (structurePoolElement instanceof SinglePoolElement singlePoolElement) {
-            if (singlePoolElement.location.left().isEmpty()) return null;
+            if (singlePoolElement.template.left().isEmpty()) return null;
 
-            return singlePoolElement.location.left().get();
+            return singlePoolElement.template.left().get();
         } else {
             return null;
         }
     }
-
-//    private List<StructurePoolElement> removeInstanceOfLocationKeyFrom(List<StructurePoolElement> structureList, Integer allowedNumberOfInstances, Identifier locationKey) {
-//        List<StructurePoolElement> reducedList = new ArrayList<>();
-//        int instancesFound = 0;
-//
-//        for (StructurePoolElement structurePoolElement: structureList) {
-//            Identifier structureKey = getCobblemonOnlyLocation(structurePoolElement);
-//            if (structureKey == null || !structureKey.equals(locationKey)) {
-//                reducedList.add(structurePoolElement);
-//                continue;
-//            }
-//
-//            if (instancesFound >= allowedNumberOfInstances) {
-//                continue;
-//            }
-//
-//            reducedList.add(structurePoolElement);
-//            instancesFound++;
-//        }
-//
-//        return  reducedList;
-//    }
-}
+}

common/src/main/java/com/cobblemon/mod/common/mixin/StructureProcessorListMixin.java

@@ -12,8 +12,8 @@ import com.cobblemon.mod.common.bridges.StructureProcessorListBridge;
 import com.google.common.collect.ImmutableList;
 import java.util.ArrayList;
 import java.util.List;
-import net.minecraft.structure.processor.StructureProcessor;
-import net.minecraft.structure.processor.StructureProcessorList;
+import net.minecraft.world.level.levelgen.structure.templatesystem.StructureProcessor;
+import net.minecraft.world.level.levelgen.structure.templatesystem.StructureProcessorList;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Mutable;

common/src/main/java/com/cobblemon/mod/common/mixin/SweetBerryBushBlockMixin.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.bedrockk.molang.runtime.value.DoubleValue;
+import com.cobblemon.mod.common.entity.MoLangScriptingEntity;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.SweetBerryBushBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+
+@Mixin(SweetBerryBushBlock.class)
+public abstract class SweetBerryBushBlockMixin {
+
+    @Inject(method = "entityInside", at = @At(value = "HEAD"), cancellable = true)
+    private void cobblemon$entityInside(BlockState state, Level level, BlockPos pos, Entity entity, CallbackInfo callbackInfo) {
+        if (entity instanceof MoLangScriptingEntity) {
+            if (((MoLangScriptingEntity) entity).getConfig().getMap().getOrDefault("immune_to_sweet_berry_bush_block", DoubleValue.ZERO).asDouble() == 1.0) {
+                callbackInfo.cancel();
+            }
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/TargetingConditionsMixin.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.Cobblemon;
+import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.ai.targeting.TargetingConditions;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(TargetingConditions.class)
+public class TargetingConditionsMixin {
+
+    @Inject(method = "test", at = @At("HEAD"), cancellable = true)
+    public void test(@Nullable LivingEntity baseEntity, LivingEntity targetEntity, CallbackInfoReturnable<Boolean> ci) {
+        if (targetEntity instanceof ServerPlayer player) {
+            if (player.level().getGameRules().getBoolean(CobblemonGameRules.MOB_TARGET_IN_BATTLE)) return;
+            boolean targetInBattle = Cobblemon.INSTANCE.getBattleRegistry().getBattleByParticipatingPlayer(player) != null;
+            if (targetInBattle) ci.setReturnValue(false);
+        }
+    }
+}