Remove a bunch of functionality related to battles :D

Animated Texture Interpolation for Cobblemon

See merge request cable-mc/cobblemon!1545

.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-PC.md

@@ -0,0 +1,16 @@
+### Additions
+
+- Added ability to rename PC Boxes by clicking on the name of a box
+- Added ability to set wallpapers per PC Box by clicking the button right to the box name
+- Added sorting by Name, Level and type by clicking the button left of the box name (shift reverses order)
+- Added filtering/search functionality in PC UI, which also supports pokemon properties (e.g. shiny=yes shows all shinies)
+- Added /changewallpaper <player> <boxNumber> <wallpaper> command to change a wallpaper through commands
+- Added /renamebox <player> <boxNumber> <name> command to rename a PC box through commands
+
+### Developer
+
+- Added RenamePCBoxEvent.Pre/Post events to prevent players from renaming a box or change their input
+- Added ChangePCBoxWallpaperEvent.Pre/Post to prevent players from changing to a wallpaper or change their selection
+- Added WallpaperCollectionEvent which gets called when clients connect to a server, allowing the server which of the clients found wallpapers it's allowed to move (collected wallpapers can be removed for example to make it "vanish" client-side)
+- 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
+- Renamed `SetPCBoxPokemonPacket` and the respective handler to `SetPCBoxPacket`

CHANGELOG-RIDING.md

@@ -0,0 +1,3 @@
+### Additions
+
+- Added the ability to ride Pokémon by shift-right clicking and selecting the ride option.

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. 

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
 

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,12 @@
 plugins {
-    base
     id("cobblemon.root-conventions")
+    id ("net.nemerosa.versioning") version "3.1.0"
 }
 
-group = "com.cobblemon.mod"
 version = "${project.property("mod_version")}+${project.property("mc_version")}"
 
 val isSnapshot = project.property("snapshot")?.equals("true") ?: false
 if (isSnapshot) {
-    version = "$version-SNAPSHOT"
-}
+    val fixedBranchName = versioning.info.branch.substringAfter("/")
+    version = "$version-${fixedBranchName}-${versioning.info.build}"
+}

common/build.gradle.kts

@@ -1,3 +1,9 @@
+import java.time.OffsetDateTime
+import java.time.ZoneOffset
+import java.time.format.DateTimeFormatter
+import utilities.isSnapshot
+import utilities.version
+
 /*
  *
  *  * Copyright (C) 2023 Cobblemon Contributors
@@ -11,42 +17,46 @@
 plugins {
     id("cobblemon.base-conventions")
     id("cobblemon.publish-conventions")
+
+    id("net.kyori.blossom")
+    id("org.jetbrains.gradle.plugin.idea-ext")
+    id("net.nemerosa.versioning") version "3.1.0"
 }
 
 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")
     mavenLocal()
 }
 
 dependencies {
-    implementation(libs.stdlib)
-    implementation(libs.reflect)
+    implementation(libs.bundles.kotlin)
+    implementation("jakarta.websocket:jakarta.websocket-api:2.2.0")
 
-    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)
+    modImplementation(libs.fabric.loader)
     modApi(libs.molang)
-    compileOnlyApi(libs.jeiApi)
 
-    // For Showdown
+    // Integrations
+    compileOnlyApi(libs.jei.api)
+    modCompileOnly(libs.bundles.common.integrations.compileOnly) {
+        isTransitive = false
+    }
+    // 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> {
@@ -56,3 +66,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/Rollable.java

@@ -0,0 +1,124 @@
+/*
+ * 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 net.minecraft.util.Mth;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix3f;
+import org.joml.Vector3f;
+
+import java.util.function.Function;
+
+public interface Rollable {
+
+    // From Minecraft's Camera
+    Vector3f FORWARDS = new Vector3f(0.0F, 0.0F, -1.0F);
+    Vector3f UP = new Vector3f(0.0F, 1.0F, 0.0F);
+    Vector3f LEFT = new Vector3f(-1.0F, 0.0F, 0.0F);
+
+    @Nullable Matrix3f getOrientation();
+
+    Rollable updateOrientation(Function<Matrix3f, Matrix3f> update);
+
+    /**
+     * @return The forward vector (0, 0, -1) after the rotation matrix is applied.
+     */
+    default Vector3f getForwardVector() {
+        if (getOrientation() == null) return new Vector3f(FORWARDS);
+        return getOrientation().transform(FORWARDS, new Vector3f());
+    }
+
+    /**
+     * @return The left vector (-1, 0, 0) after the rotation matrix is applied.
+     */
+    default Vector3f getLeftVector() {
+        if (getOrientation() == null) return new Vector3f(LEFT);
+        return getOrientation().transform(LEFT, new Vector3f());
+    }
+
+    /**
+     * @return The up vector (0, 1, 0) after the rotation matrix is applied.
+     */
+    default Vector3f getUpVector() {
+        if (getOrientation() == null) return new Vector3f(UP);
+        return getOrientation().transform(UP, new Vector3f());
+    }
+
+    /**
+     *
+     * @param yaw change in degrees
+     * @return The Rollable object this method was called on
+     */
+
+    default Rollable rotateYaw(float yaw) {
+        return updateOrientation(prev -> prev.rotateY((float) Math.toRadians(-yaw)));
+    }
+
+    /**
+     *
+     * @param pitch change in degrees
+     * @return The Rollable object this method was called on
+     */
+
+    default Rollable rotatePitch(float pitch) {
+        return updateOrientation(prev -> prev.rotateX((float) Math.toRadians(-pitch)));
+    }
+
+    /**
+     *
+     * @param roll change in degrees
+     * @return The Rollable object this method was called on
+     */
+    default Rollable rotateRoll(float roll) {
+        return updateOrientation(prev -> prev.rotateZ((float) Math.toRadians(-roll)));
+    }
+
+
+    /**
+     * Order matters when rotating an object. If you need a different order, individually call rotateYaw, rotatePitch, and rotateRoll
+     *
+     * @param yaw change in degrees
+     * @param pitch change in degrees
+     * @param roll change in degrees
+     * @return The Rollable object this method was called on
+     */
+    default Rollable rotate(float yaw, float pitch, float roll) {
+        return rotateYaw(yaw).rotatePitch(pitch).rotateRoll(roll);
+    }
+
+    /**
+     * @return The pitch angle in degrees as a float.
+     * Value is between [-180, 180] with 0 being South, 90 being West, 180/-180 being North, and -90 being East
+     */
+    default float getYaw() {
+        return (float) Mth.wrapDegrees(-Math.toDegrees(FORWARDS.angleSigned(getForwardVector(), UP)) + 180);
+    }
+
+    /**
+     * @return The yaw angle in degrees as a float.
+     * Value is between [-90, 90] with 0 being straight forward, 90 being straight down, and -90 being straight up
+     */
+    default float getPitch() {
+        return (float) Mth.wrapDegrees(-Math.toDegrees(Math.asin(getForwardVector().y)));
+    }
+
+    /**
+     * @return The roll angle in degrees as a float.
+     * Value is between [-180, 180] with 0 being no roll (normal), 90 being 90 degrees CW, 180/-180 being 180 degrees CW/CCW, and -90 being 90 degrees CCW
+     */
+    default float getRoll() {
+        //Cobblemon.LOGGER.info("{}", (float) Math.toDegrees(getUpVector().angleSigned(UP, getForwardVector())));
+        return (float) Mth.wrapDegrees(-Math.toDegrees(getUpVector().angleSigned(UP, getForwardVector())));
+    }
+
+    boolean shouldRoll();
+
+    void clearRotation();
+
+}

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/LambDynamicLightsCompat.java

@@ -0,0 +1,85 @@
+/*
+ * 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;
+
+import com.cobblemon.mod.common.CobblemonEntities;
+import com.cobblemon.mod.common.client.render.layer.PokemonOnShoulderRenderer;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.cobblemon.mod.common.pokemon.FormData;
+import com.cobblemon.mod.common.pokemon.lighthing.LightingData;
+import dev.lambdaurora.lambdynlights.api.DynamicLightHandler;
+import dev.lambdaurora.lambdynlights.api.DynamicLightHandlers;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.EntityType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Optional;
+
+import net.minecraft.world.entity.player.Player;
+
+// Java class due to relying on entrypoint on Fabric side
+public class LambDynamicLightsCompat {
+
+    // This is all called on client side
+    // These things are checked every tick so try to keep it as free as possible
+    // That being said it's unlikely school Toshiba person is running dynamic lighting and shaders to enjoy this
+    // Make sure not to call anything Fabric specific :)
+    public static void hookCompat() {
+        // Pokémon entities
+        DynamicLightHandlers.registerDynamicLightHandler(
+                CobblemonEntities.POKEMON,
+                DynamicLightHandler.makeHandler(
+                        LambDynamicLightsCompat::resolvedPokemonLightLevel,
+                        pokemon -> false
+                )
+        );
+
+        // Shouldered Pokémon
+        DynamicLightHandlers.registerDynamicLightHandler(
+                EntityType.PLAYER,
+                DynamicLightHandler.makeHandler(
+                        LambDynamicLightsCompat::resolvedShoulderLightLevel,
+                        player -> false
+                )
+        );
+    }
+
+    private static int resolvedPokemonLightLevel(PokemonEntity pokemon) {
+        var underwater = !pokemon.level().getFluidState(BlockPos.containing(pokemon.getX(), pokemon.getEyeY(), pokemon.getZ())).isEmpty();
+        return extractFormLightLevel(pokemon.getForm(), underwater).orElse(0);
+    }
+
+    private static int resolvedShoulderLightLevel(Player player) {
+        final var shoulderDataPair = PokemonOnShoulderRenderer.shoulderDataOf(player);
+        var underwater = !player.level().getFluidState(BlockPos.containing(player.getX(), player.getEyeY(), player.getZ())).isEmpty();
+        final Optional<Integer> leftLightLevel = extractShoulderLightLevel(shoulderDataPair.getFirst(), underwater);
+        final Optional<Integer> rightLightLevel = extractShoulderLightLevel(shoulderDataPair.getSecond(), underwater);
+        return Math.max(leftLightLevel.orElse(0), rightLightLevel.orElse(0));
+    }
+
+    private 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());
+    }
+
+    private static Optional<Integer> extractShoulderLightLevel(@Nullable PokemonOnShoulderRenderer.ShoulderData shoulderData, boolean underwater) {
+        if (shoulderData == null) {
+            return Optional.empty();
+        }
+        return extractFormLightLevel(shoulderData.getForm(), underwater);
+    }
+
+    private static boolean liquidGlowModeSupport(@NotNull LightingData.LiquidGlowMode liquidGlowMode, boolean underwater) {
+        return underwater ? liquidGlowMode.getGlowsUnderwater() : liquidGlowMode.getGlowsInLand();
+    }
+
+}

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/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/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/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/EntityRenderDispatcherMixin.java

@@ -9,10 +9,20 @@
 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.MatrixWrapper;
+import com.cobblemon.mod.common.client.render.models.blockbench.PosableModel;
+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.MultiBufferSource;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec3;
+import org.joml.Vector3f;
+import org.spongepowered.asm.mixin.Debug;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
@@ -20,17 +30,57 @@ import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 import java.util.Map;
+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.player.Player;
 
 @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
+                    );
+                    poseStack.popPose();
+                });
+
+            }
+        }
+    }
+}

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/FenceBlockMixin.java

@@ -1,47 +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.CobblemonBlocks;
-import com.cobblemon.mod.common.block.PastureBlock;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.FenceBlock;
-import net.minecraft.block.HorizontalFacingBlock;
-import net.minecraft.util.math.Direction;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-@Mixin(value = FenceBlock.class)
-public abstract class FenceBlockMixin {
-
-    // This could be done with a modify variable but it just doesn't seem to want to work, very crude unfinished explanation I had on Fabric discord was
-    // "boolean is a primitive, it isnt passed by reference but by value and you have your own object references anyway so assigning a new object to non-primitive references (variables) wont modify it after your mixin returns
-    //(you cant modify a random argument that mixin passes you that way, target the boolean not the FenceBlock)"
-    // However the issue is the only way to get all the params which we need is by passing in the entire method reference which enforces the return type.
-
-    @Redirect(method = "getStateForNeighborUpdate", at = @At(value = "INVOKE", target = "Lnet/minecraft/block/FenceBlock;canConnect(Lnet/minecraft/block/BlockState;ZLnet/minecraft/util/math/Direction;)Z"))
-    private boolean cobblemon$getStateForNeighborUpdate(FenceBlock instance, BlockState state, boolean neighborIsFullSquare, Direction dir) {
-        return instance.canConnect(state, neighborIsFullSquare, dir) || this.cobblemon$canConnect(state, dir);
-    }
-
-    @Redirect(method = "getPlacementState", at = @At(value = "INVOKE", target = "Lnet/minecraft/block/FenceBlock;canConnect(Lnet/minecraft/block/BlockState;ZLnet/minecraft/util/math/Direction;)Z"))
-    private boolean cobblemon$getPlacementState(FenceBlock instance, BlockState state, boolean neighborIsFullSquare, Direction dir) {
-        return instance.canConnect(state, neighborIsFullSquare, dir) || this.cobblemon$canConnect(state, dir);
-    }
-
-    private boolean cobblemon$canConnect(BlockState state, Direction dir) {
-        if (state.isOf(CobblemonBlocks.PASTURE) && state.get(PastureBlock.Companion.getPART()) == PastureBlock.PasturePart.BOTTOM) {
-            final Direction pastureFacing = state.get(HorizontalFacingBlock.FACING);
-            return dir == pastureFacing.rotateYClockwise() || dir == pastureFacing.rotateYCounterclockwise();
-        }
-        return false;
-    }
-
-}

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/LivingEntityMixin.java

@@ -9,9 +9,9 @@
 package com.cobblemon.mod.common.mixin;
 
 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 net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.effect.MobEffectInstance;
+import net.minecraft.world.entity.LivingEntity;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -20,11 +20,11 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 @Mixin(LivingEntity.class)
 public abstract class LivingEntityMixin {
 
-    @Inject(method = "onStatusEffectRemoved", at = @At(value = "TAIL"))
-    private void cobblemon$onStatusEffectRemoved(StatusEffectInstance effect, CallbackInfo ci) {
+    @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);
         }
     }
 

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/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/PlayerMixin.java

@@ -10,78 +10,102 @@ package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.Cobblemon;
 import com.cobblemon.mod.common.CobblemonItems;
+import com.cobblemon.mod.common.Rollable;
 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.pokemon.PokemonSpecies;
+import com.cobblemon.mod.common.api.riding.Rideable;
 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.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.client.Minecraft;
+import net.minecraft.client.player.LocalPlayer;
+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.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+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.item.Items;
+import net.minecraft.world.level.Level;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix3f;
 import org.objectweb.asm.Opcodes;
 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.List;
 import java.util.Objects;
+import java.util.Set;
 import java.util.UUID;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
-import static com.cobblemon.mod.common.util.LocalizationUtilsKt.lang;
+@Mixin(Player.class)
+public abstract class PlayerMixin extends LivingEntity implements Rollable, ScannableEntity {
 
-@Mixin(PlayerEntity.class)
-public abstract class PlayerMixin extends LivingEntity {
+    @Shadow public abstract CompoundTag getShoulderEntityLeft();
 
-    @Shadow public abstract NbtCompound getShoulderEntityLeft();
+    @Shadow public abstract CompoundTag getShoulderEntityRight();
 
-    @Shadow public abstract NbtCompound getShoulderEntityRight();
+    @Shadow public abstract void respawnEntityOnShoulder(CompoundTag entityNbt);
 
-    @Shadow public abstract void dropShoulderEntity(NbtCompound entityNbt);
+    @Shadow public abstract void setShoulderEntityRight(CompoundTag entityNbt);
 
-    @Shadow public abstract void setShoulderEntityRight(NbtCompound 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);
 
+    @Unique private Matrix3f orientation = null;
 
-    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();
@@ -89,7 +113,7 @@ public abstract class PlayerMixin extends LivingEntity {
     }
 
     @Inject(
-        method = "dropShoulderEntities",
+        method = "removeEntitiesOnShoulder",
         at = @At(
             value = "JUMP",
             opcode = Opcodes.IFGE,
@@ -100,61 +124,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 +175,141 @@ 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 (shouldRoll()) {
+            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);
+        }
+    }
+
+    @Inject(method = "tick", at = @At("HEAD"))
+    public void tick(CallbackInfo ci) {
+        if (this.shouldRoll()) {
+            // Proof of concept for yaw movement
+            if (this.getMainHandItem().is(Items.STICK)) {
+                this.rotateYaw(2);
+            }
+            else if (this.getMainHandItem().is(Items.BLAZE_ROD)) {
+                this.rotateYaw(-2);
+            }
+        }
+    }
+
+    @Override
+    public Matrix3f getOrientation() {
+        return orientation;
+    }
+
+    @Override
+    public Rollable updateOrientation(Function<Matrix3f, Matrix3f> update) {
+        if (!shouldRoll()) return this;
+
+        if (this.orientation == null) {
+            this.orientation = new Matrix3f();
+            this.rotate(getYRot() - 180, getXRot(), 0);
+        }
+        this.orientation = update.apply(this.orientation);
+        setYRot(this.getYaw());
+        setXRot(this.getPitch());
+        return this;
+    }
+
+    @Override
+    public boolean shouldRoll() {
+        LocalPlayer player = Minecraft.getInstance().player;
+        if (!this.equals(player)) return false;
+        if (player.isHolding(Items.DIAMOND)) return true;
+
+        var playerVehicle = player.getVehicle();
+        if (playerVehicle == null) return false;
+        if (!(playerVehicle instanceof PokemonEntity pokemonEntity)) return false;
+
+        return pokemonEntity.getRiding().shouldRoll(pokemonEntity);
+    }
+
+    @Override
+    public void clearRotation() {
+        this.orientation = null;
+    }
+
+    @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 Rideable vehicle) {
+            return vehicle.getRiding().dismountOnShift() && original.call(instance);
+        }
+        return original.call(instance);
+    }
+
+}

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 = "canTipGrow(Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/server/level/ServerLevel;Lnet/minecraft/core/BlockPos;)Z",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/block/state/BlockState;is(Lnet/minecraft/world/level/Block;)Z", ordinal = 0),
+            slice = @Slice(from = @At(value = "FIELD", target = "Lnet/minecraft/world/level/block/Blocks;DRIPSTONE_BLOCK:Lnet/minecraft/world/level/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/ServerChunkManagerMixin.java

@@ -1,44 +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.spawning.mixins.CachedOnlyChunkAccessor;
-import com.mojang.datafixers.util.Either;
-import net.minecraft.server.world.ChunkHolder;
-import net.minecraft.server.world.ServerChunkManager;
-import net.minecraft.util.math.ChunkPos;
-import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.chunk.ChunkManager;
-import net.minecraft.world.chunk.ChunkStatus;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-
-import java.util.concurrent.CompletableFuture;
-
-@Mixin(ServerChunkManager.class)
-public abstract class ServerChunkManagerMixin extends ChunkManager implements CachedOnlyChunkAccessor {
-    @Shadow @Nullable protected abstract ChunkHolder getChunkHolder(long pos);
-
-    @Override
-    public Chunk cobblemon$request(int x, int z, @NotNull ChunkStatus status) {
-        long l = ChunkPos.toLong(x, z);
-
-        ChunkHolder holder = getChunkHolder(l);
-        if (holder != null) {
-            CompletableFuture<Either<Chunk, ChunkHolder.Unloaded>> future = holder.getFutureFor(status);
-            if (future.isDone()) {
-                return future.join().left().orElse(null);
-            }
-        }
-
-        return null;
-    }
-}

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/SoundEngineMixin.java

@@ -0,0 +1,113 @@
+/*
+ * 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 com.cobblemon.mod.common.duck.SoundEngineDuck;
+import com.google.common.collect.Multimap;
+import com.mojang.blaze3d.audio.Channel;
+import net.minecraft.client.resources.sounds.SoundInstance;
+import net.minecraft.client.sounds.ChannelAccess;
+import net.minecraft.client.sounds.SoundEngine;
+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;
+
+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);
+
+    /** 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,90 @@
 
 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.BlockEntitySoundTracker;
+import com.cobblemon.mod.common.client.sound.EntitySoundTracker;
+import com.cobblemon.mod.common.client.sound.BattleMusicController;
+import com.cobblemon.mod.common.client.sound.SoundTracker;
+import com.cobblemon.mod.common.duck.SoundManagerDuck;
+import com.cobblemon.mod.common.duck.SoundEngineDuck;
+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/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/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) {
+            boolean canTargetInBattle = player.level().getGameRules().getBoolean(CobblemonGameRules.MOB_TARGET_IN_BATTLE);
+            boolean targetInBattle = Cobblemon.INSTANCE.getBattleRegistry().getBattleByParticipatingPlayer(player) != null;
+            if (!canTargetInBattle && targetInBattle) ci.setReturnValue(false);
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+/*
+ * 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.CobblemonVillagerProfessions;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import kotlin.Pair;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.model.EntityModel;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.LivingEntityRenderer;
+import net.minecraft.client.renderer.entity.layers.RenderLayer;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.monster.ZombieVillager;
+import net.minecraft.world.entity.npc.Villager;
+import net.minecraft.world.entity.npc.VillagerProfession;
+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(RenderLayer.class)
+public abstract class VillagerProfessionLayerMixin {
+    @Inject(method = "renderColoredCutoutModel", at = @At(value = "HEAD"), cancellable = true)
+    private static <T extends LivingEntity> void cobblemon$renderVillagerProfessionLayer(EntityModel<T> entityModel, ResourceLocation resourceLocation, PoseStack poseStack, MultiBufferSource multiBufferSource, int i, T livingEntity, int j, CallbackInfo ci) {
+        if (resourceLocation.getNamespace().equals(Cobblemon.MODID)) {
+            VillagerProfession profession = null;
+            boolean isZombie = false;
+
+            if (livingEntity instanceof Villager) profession = ((Villager) livingEntity).getVillagerData().getProfession();
+            if (livingEntity instanceof ZombieVillager) {
+                profession = ((ZombieVillager) livingEntity).getVillagerData().getProfession();
+                isZombie = true;
+            }
+
+            Pair<String, String[]> override = CobblemonVillagerProfessions.INSTANCE.getNameTagOverride(profession);
+            if (profession != null && override != null) {
+                String entityName = ChatFormatting.stripFormatting(livingEntity.getName().getString());
+                boolean nameMatches = false;
+                for (String name: override.getSecond())
+                    if (entityName.endsWith(name)) {
+                        nameMatches = true;
+                        break;
+                    }
+                if (nameMatches && resourceLocation.equals(getProfessionResourceLocation(resourceLocation.getNamespace(), ResourceLocation.parse(profession.name()).getPath(), isZombie))) {
+                    ResourceLocation textureLocation = getProfessionResourceLocation(resourceLocation.getNamespace(), override.getFirst(), isZombie);
+                    VertexConsumer vertexConsumer = multiBufferSource.getBuffer(RenderType.entityCutoutNoCull(textureLocation));
+                    entityModel.renderToBuffer(poseStack, vertexConsumer, i, LivingEntityRenderer.getOverlayCoords(livingEntity, 0.0F), j);
+                    ci.cancel();
+                }
+            }
+        }
+    }
+
+    private static ResourceLocation getProfessionResourceLocation(String namespace, String profession, Boolean isZombie) {
+        return ResourceLocation.fromNamespaceAndPath(namespace, "textures/entity/" + (isZombie ? "zombie_villager" : "villager") + "/profession/" + profession + ".png");
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/AccessorEntity.java

@@ -8,14 +8,14 @@
 
 package com.cobblemon.mod.common.mixin.accessor;
 
-import net.minecraft.entity.Entity;
+import net.minecraft.world.entity.Entity;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.gen.Accessor;
 
 @Mixin(Entity.class)
 public interface AccessorEntity {
 
-    @Accessor("standingEyeHeight")
+    @Accessor("eyeHeight")
     void standingEyeHeight(float standingEyeHeight);
 
 }

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/BiomeAccessor.java

@@ -0,0 +1,19 @@
+/*
+ * 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.accessor;
+
+import net.minecraft.world.level.biome.Biome;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(Biome.class)
+public interface BiomeAccessor {
+    @Accessor("climateSettings")
+    Biome.ClimateSettings getClimateSettings();
+}

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/BoatEntityAccessor.java

@@ -0,0 +1,23 @@
+/*
+ * 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.accessor;
+
+import net.minecraft.world.entity.vehicle.Boat;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(Boat.class)
+public interface BoatEntityAccessor {
+
+    @Accessor("lastYd")
+    void setFallVelocity(double fallVelocity);
+
+    @Accessor("status")
+    Boat.Status getLocation();
+}

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/EntryListWidgetAccessor.java

@@ -0,0 +1,19 @@
+/*
+ * 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.accessor;
+
+import net.minecraft.client.gui.components.AbstractSelectionList;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(AbstractSelectionList.class)
+public interface EntryListWidgetAccessor {
+    @Accessor("renderHeader")
+    boolean getRenderHeader();
+}

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/KeyBindingAccessor.java

@@ -8,15 +8,15 @@
 
 package com.cobblemon.mod.common.mixin.accessor;
 
-import net.minecraft.client.option.KeyBinding;
-import net.minecraft.client.util.InputUtil;
+import com.mojang.blaze3d.platform.InputConstants;
+import net.minecraft.client.KeyMapping;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.gen.Accessor;
 
-@Mixin(KeyBinding.class)
+@Mixin(KeyMapping.class)
 public interface KeyBindingAccessor {
 
-    @Accessor("boundKey")
-    InputUtil.Key boundKey();
+    @Accessor("key")
+    InputConstants.Key boundKey();
 
 }

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/MusicTrackerAccessor.java

@@ -1,22 +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.accessor;
-
-import net.minecraft.client.sound.MusicTracker;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-@Mixin(MusicTracker.class)
-public interface MusicTrackerAccessor {
-    @Accessor("timeUntilNextSong")
-    int timeUntilNextSong();
-
-    @Accessor("timeUntilNextSong")
-    void setTimeUntilNextSong(int timeUntilNextSong);
-}

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/StatusEffectInstanceAccessor.java

@@ -8,17 +8,17 @@
 
 package com.cobblemon.mod.common.mixin.accessor;
 
-import net.minecraft.entity.effect.StatusEffectInstance;
+import net.minecraft.world.effect.MobEffectInstance;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.gen.Accessor;
 
-@Mixin(StatusEffectInstance.class)
+@Mixin(MobEffectInstance.class)
 public interface StatusEffectInstanceAccessor {
 
     @Accessor
     void setAmplifier(int amplifier);
 
-    @Accessor
+    @Accessor("visible")
     void setShowParticles(boolean showParticles);
 
     @Accessor

common/src/main/java/com/cobblemon/mod/common/mixin/client/AbstractClientPlayerMixin.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.client;
+
+import com.cobblemon.mod.common.client.CobblemonClient;
+import com.cobblemon.mod.common.pokedex.scanner.PokedexUsageContext;
+import net.minecraft.client.player.AbstractClientPlayer;
+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(AbstractClientPlayer.class)
+public class AbstractClientPlayerMixin {
+    @Inject(
+        method = "getFieldOfViewModifier()F",
+        at = @At(
+            value = "HEAD"
+        ),
+        cancellable = true
+    )
+    public void cobblemon$getPokedexFovMultiplier(CallbackInfoReturnable<Float> cir) {
+        PokedexUsageContext usageContext = CobblemonClient.INSTANCE.getPokedexUsageContext();
+        if (usageContext.getScanningGuiOpen()) {
+            cir.setReturnValue(usageContext.getFovMultiplier());
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/client/CameraMixin.java

@@ -0,0 +1,97 @@
+/*
+ * 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.client;
+
+import com.cobblemon.mod.common.Rollable;
+import net.minecraft.client.Camera;
+import net.minecraft.client.Minecraft;
+import net.minecraft.world.entity.Entity;
+import org.joml.Matrix3f;
+import org.joml.Quaternionf;
+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;
+
+@Mixin(Camera.class)
+public abstract class CameraMixin {
+    @Shadow @Final private static float DEFAULT_CAMERA_DISTANCE;
+
+    @Shadow private Entity entity;
+    @Shadow @Final private Quaternionf rotation;
+    @Shadow @Final private Vector3f forwards;
+    @Shadow @Final private Vector3f up;
+    @Shadow @Final private Vector3f left;
+    @Shadow private float xRot;
+    @Shadow private float yRot;
+
+    @Shadow public abstract float getXRot();
+
+    @Shadow public abstract float getYRot();
+
+    @Unique private float returnTimer = 0;
+    @Unique private float rollAngleStart = 0;
+    @Unique Minecraft minecraft = Minecraft.getInstance();
+
+    @Unique boolean disableRollableCameraDebug = false;
+
+    @Inject(method = "setRotation", at = @At("HEAD"), cancellable = true)
+    public void open_camera$setRotation(float f, float g, CallbackInfo ci) {
+        if (!(this.entity instanceof Rollable rollable) || disableRollableCameraDebug) return;
+        if (!rollable.shouldRoll() && rollable.getOrientation() != null) {
+            if(this.returnTimer < 1) {
+                //Rotation is taken from entity since we no longer handle mouse ourselves
+                //Stops a period of time when you can't input anything.
+                rollable.getOrientation().set(
+                        new Matrix3f()
+                                .rotateY((float) Math.toRadians(180 - this.entity.getYRot()))
+                                .rotateX((float) Math.toRadians(-this.entity.getXRot()))
+                );
+                if(rollAngleStart == 0){
+                    this.returnTimer = 1;
+                    rollable.clearRotation();
+                    return;
+                }
+                rollable.getOrientation().rotateZ((float) Math.toRadians(-rollAngleStart*(1-returnTimer)));
+                applyRotation();
+                this.returnTimer += .05F;
+                ci.cancel();
+            } else {
+                this.returnTimer = 1;
+                rollable.clearRotation();
+            }
+            return;
+        }
+        if (rollable.getOrientation() == null) return;
+        applyRotation();
+
+        this.returnTimer = 0;
+        this.rollAngleStart = rollable.getRoll();
+        ci.cancel();
+    }
+
+    @Unique
+    private void applyRotation(){
+        if (!(this.entity instanceof Rollable rollable) || rollable.getOrientation() == null) return;
+        var newRotation = rollable.getOrientation().normal(new Matrix3f()).getNormalizedRotation(new Quaternionf());
+        if (this.minecraft.options.getCameraType().isMirrored()) {
+            newRotation.rotateY((float)Math.toRadians(180));
+        }
+        this.rotation.set(newRotation);
+        this.xRot = rollable.getPitch();
+        this.yRot = rollable.getYaw();
+        this.forwards.set(rollable.getForwardVector());
+        this.up.set(rollable.getUpVector());
+        this.left.set(rollable.getLeftVector());
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/client/EntryListWidgetMixin.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.client;
+
+import com.cobblemon.mod.common.client.gui.ScrollingWidget;
+import net.minecraft.client.gui.components.AbstractSelectionList;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.Constant;
+import org.spongepowered.asm.mixin.injection.ModifyConstant;
+
+@Mixin(AbstractSelectionList.class)
+public abstract class EntryListWidgetMixin {
+
+    @SuppressWarnings("ConstantValue")
+    @ModifyConstant(method = "getEntryAtPosition", constant = @Constant(intValue = 4))
+    public int cobblemon$adjustOnlyIfNecessary(int input) {
+        if(ScrollingWidget.class.isInstance(this)) {
+            return 0;
+        }
+
+        return input;
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/client/GameRendererMixin.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.mixin.client;
+
+import com.cobblemon.mod.common.api.scheduling.ClientTaskTracker;
+import net.minecraft.client.DeltaTracker;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.GameRenderer;
+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(GameRenderer.class)
+public class GameRendererMixin {
+    @Unique
+    long lastTime = -1;
+
+    @Inject(
+            method = "render",
+            at = @At(value = "TAIL")
+    )
+    public void render(DeltaTracker counter, boolean tick, CallbackInfo ci) {
+        Minecraft client = Minecraft.getInstance();
+        long newTime = System.currentTimeMillis();
+        // Don't play scheduled animations when the game is paused
+        if (client.isPaused()) {
+            lastTime = newTime;
+            return;
+        }
+
+        if (lastTime != -1) {
+            ClientTaskTracker.INSTANCE.update((newTime - lastTime) / 1000F);
+        }
+        lastTime = newTime;
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/client/HumanoidModelMixin.java

@@ -0,0 +1,66 @@
+/*
+ * 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.client;
+
+import com.cobblemon.mod.common.client.render.player.MountedPlayerRenderer;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.client.model.HumanoidModel;
+import net.minecraft.client.model.geom.ModelPart;
+import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+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.HashMap;
+
+@Mixin(HumanoidModel.class)
+public class HumanoidModelMixin {
+    @Unique HashMap<String, ModelPart> relevantPartsByName = new HashMap<>();
+
+    @Shadow @Final
+    public ModelPart head;
+    @Shadow @Final
+    public ModelPart rightArm;
+    @Shadow @Final
+    public ModelPart leftArm;
+    @Shadow @Final
+    public ModelPart rightLeg;
+    @Shadow @Final
+    public ModelPart leftLeg;
+
+    @Inject(method = "setupAnim*", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/model/geom/ModelPart;copyFrom(Lnet/minecraft/client/model/geom/ModelPart;)V", shift = At.Shift.BEFORE))
+    public void cobblemon$animateRiders(
+        LivingEntity entity,
+        float limbSwing,
+        float limbSwingAmount,
+        float ageInTicks,
+        float netHeadYaw,
+        float headPitch,
+        CallbackInfo ci
+    ) {
+        if (relevantPartsByName.isEmpty()) {
+            relevantPartsByName.put("arm_left", leftArm);
+            relevantPartsByName.put("arm_right", rightArm);
+            relevantPartsByName.put("leg_left", leftLeg);
+            relevantPartsByName.put("leg_right", rightLeg);
+            relevantPartsByName.put("head", head);
+        }
+
+        Entity vehicle = entity.getVehicle();
+        if (vehicle instanceof PokemonEntity && entity instanceof AbstractClientPlayer) {
+            MountedPlayerRenderer.INSTANCE.animate((PokemonEntity) vehicle, (AbstractClientPlayer) entity, relevantPartsByName, netHeadYaw, headPitch, ageInTicks, limbSwing, limbSwingAmount);
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/client/ItemInHandRendererMixin.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.mixin.client;
+
+import com.cobblemon.mod.common.Rollable;
+import com.cobblemon.mod.common.item.PokedexItem;
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.client.renderer.ItemInHandRenderer;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.item.ItemStack;
+import org.joml.Quaternionf;
+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.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ItemInHandRenderer.class)
+public class ItemInHandRendererMixin {
+    @Inject(method = "renderArmWithItem", at = @At(value = "HEAD"), cancellable = true)
+    private void cobblemon$renderArmWithItem(AbstractClientPlayer abstractClientPlayer, float f, float g, InteractionHand interactionHand, float h, ItemStack itemStack, float i, PoseStack poseStack, MultiBufferSource multiBufferSource, int j, CallbackInfo ci) {
+        if (abstractClientPlayer.isUsingItem() && abstractClientPlayer.getUseItem().getItem() instanceof PokedexItem) {
+            ci.cancel();
+        }
+        else if (abstractClientPlayer instanceof Rollable rollable && rollable.shouldRoll()) {
+
+        }
+    }
+
+    @Redirect(method = "renderHandsWithItems", at = @At(value = "INVOKE", target = "Lcom/mojang/blaze3d/vertex/PoseStack;mulPose(Lorg/joml/Quaternionf;)V", ordinal = 1))
+    private void cobblemon$renderHandswithItems(PoseStack instance, Quaternionf quaternion) {
+        if (!(Minecraft.getInstance().player instanceof Rollable rollable && rollable.shouldRoll())) {
+            instance.mulPose(quaternion);
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/client/ItemRendererMixin.java

@@ -0,0 +1,100 @@
+/*
+ * 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.client;
+
+import com.cobblemon.mod.common.Cobblemon;
+import com.cobblemon.mod.common.ModAPI;
+import com.cobblemon.mod.common.item.PokeBallItem;
+import com.cobblemon.mod.common.item.PokedexItem;
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.ItemModelShaper;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.entity.ItemRenderer;
+import net.minecraft.client.resources.model.BakedModel;
+import net.minecraft.client.resources.model.ModelResourceLocation;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemDisplayContext;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+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;
+
+/*
+    I think it would be nice to maybe use the existing mixin we have for custom item rendering [BuiltinModelItemRendererMixin]
+    Obviously that would require changes. Potentially each item renderer defines what modes it overrides for?
+ */
+@Mixin(ItemRenderer.class)
+public abstract class ItemRendererMixin {
+    // ignore the hint saying implmentation is never null, if something crashes then it is null and causes red herrings
+    @Unique private final String MODEL_PATH = (Cobblemon.implementation != null && Cobblemon.implementation.getModAPI() == ModAPI.FABRIC) ? "fabric_resource" : "standalone";
+
+    @Shadow @Final private ItemModelShaper itemModelShaper;
+
+    @Shadow public abstract void render(ItemStack stack, ItemDisplayContext renderMode, boolean leftHanded, PoseStack matrices, MultiBufferSource vertexConsumers, int light, int overlay, BakedModel model);
+
+    @Inject(
+        method = "render(Lnet/minecraft/world/item/ItemStack;Lnet/minecraft/world/item/ItemDisplayContext;ZLcom/mojang/blaze3d/vertex/PoseStack;Lnet/minecraft/client/renderer/MultiBufferSource;IILnet/minecraft/client/resources/model/BakedModel;)V",
+        at = @At("HEAD"),
+        cancellable = true
+    )
+    private void cobblemon$overrideItemModel(ItemStack stack, ItemDisplayContext renderMode, boolean leftHanded, PoseStack matrices, MultiBufferSource multiBufferSource, int light, int overlay, BakedModel model, CallbackInfo ci) {
+        boolean shouldBe2d = renderMode == ItemDisplayContext.GUI || renderMode == ItemDisplayContext.FIXED;
+        if (shouldBe2d) {
+            ResourceLocation resourceLocation = null;
+            if (stack.getItem() instanceof PokeBallItem pokeBallItem) resourceLocation = pokeBallItem.getPokeBall().getModel2d();
+            else if (stack.getItem() instanceof PokedexItem pokedexItem) resourceLocation = pokedexItem.getType().getItemSpritePath();
+
+            if (resourceLocation != null) {
+                BakedModel replacementModel = this.itemModelShaper.getModelManager().getModel(new ModelResourceLocation(resourceLocation, "inventory"));
+                if (!cobblemon$isSameModel(model, replacementModel)) {
+                    ci.cancel();
+                    render(stack, renderMode, leftHanded, matrices, multiBufferSource, light, overlay, replacementModel);
+                }
+            }
+        }
+    }
+
+    @Inject(method = "getModel", at = @At("HEAD"), cancellable = true)
+    private void cobblemon$getItemModel(ItemStack stack, Level world, LivingEntity entity, int seed, CallbackInfoReturnable<BakedModel> cir) {
+        ResourceLocation resourceLocation = null;
+        if (stack.getItem() instanceof PokeBallItem pokeBallItem) resourceLocation = pokeBallItem.getPokeBall().getModel3d();
+        else if (stack.getItem() instanceof PokedexItem pokedexItem) {
+            boolean isScanModel = entity instanceof Player && entity.getUseItem() == stack && entity.isUsingItem();
+            boolean canOpenScreen = entity != null && ((entity.getOffhandItem() == stack && !(entity.getMainHandItem().getItem() instanceof PokedexItem)) || entity.getMainHandItem() == stack);
+            resourceLocation = pokedexItem.getType().getItemModelPath(isScanModel ? "scanning" : (canOpenScreen ? null : "off"));
+        }
+
+        if (resourceLocation != null) {
+            BakedModel model = this.itemModelShaper.getModelManager().getModel(new ModelResourceLocation(resourceLocation, MODEL_PATH));
+            ClientLevel clientWorld = world instanceof ClientLevel ? (ClientLevel) world : null;
+            BakedModel overriddenModel = model.getOverrides().resolve(model, stack, clientWorld, entity, seed);
+            cir.setReturnValue(overriddenModel == null ? this.itemModelShaper.getModelManager().getMissingModel() : overriddenModel);
+        }
+    }
+
+    // this method aims to cover an issue with modernfixes and it's "dynamic resource" causing the usual .equals check to always fail, resulting in a StackOverflow
+    // this falls back to comparing the model contents (e.g. location of the texture, width and height)
+    @Unique
+    private static boolean cobblemon$isSameModel(BakedModel original, BakedModel replacement) {
+        return original.equals(replacement) ||
+                       (original.getParticleIcon().contents().name().equals(replacement.getParticleIcon().contents().name()) &&
+                                original.getParticleIcon().contents().width() == replacement.getParticleIcon().contents().width() &&
+                                original.getParticleIcon().contents().height() == replacement.getParticleIcon().contents().height());
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/client/LocalPlayerMixin.java

@@ -0,0 +1,43 @@
+/*
+ * 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.client;
+
+import com.cobblemon.mod.common.CobblemonNetwork;
+import com.cobblemon.mod.common.Rollable;
+import com.cobblemon.mod.common.net.messages.server.orientation.C2SUpdateOrientationPacket;
+import net.minecraft.client.player.LocalPlayer;
+import org.joml.Matrix3f;
+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(LocalPlayer.class)
+public class LocalPlayerMixin {
+
+    @Unique Matrix3f cobblemon$lastOrientation;
+
+    @Inject(method = "sendPosition", at = @At("TAIL"))
+    private void cobblemon_updateRotationMatrix(CallbackInfo ci) {
+        if (!(this instanceof Rollable rollable)) return;
+        if (rollable.getOrientation() == cobblemon$lastOrientation) return;
+        cobblemon$lastOrientation = rollable.getOrientation() != null ? new Matrix3f(rollable.getOrientation()) : null;
+        CobblemonNetwork.INSTANCE.sendToServer(new C2SUpdateOrientationPacket(rollable.getOrientation()));
+    }
+
+    @Inject(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/multiplayer/ClientPacketListener;send(Lnet/minecraft/network/protocol/Packet;)V"))
+    private void cobblemon_updateRotationMatrixPassenger(CallbackInfo ci) {
+        if (!(this instanceof Rollable rollable)) return;
+        if (rollable.getOrientation() == cobblemon$lastOrientation) return;
+        cobblemon$lastOrientation = rollable.getOrientation() != null ? new Matrix3f(rollable.getOrientation()) : null;
+        CobblemonNetwork.INSTANCE.sendToServer(new C2SUpdateOrientationPacket(rollable.getOrientation()));
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/client/ModelLoaderMixin.java

@@ -0,0 +1,49 @@
+/*
+ * 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.client;
+
+import com.cobblemon.mod.common.client.CobblemonBakingOverrides;
+import java.util.List;
+import java.util.Map;
+import net.minecraft.client.color.block.BlockColors;
+import net.minecraft.client.renderer.block.model.BlockModel;
+import net.minecraft.client.resources.model.BlockStateModelLoader;
+import net.minecraft.client.resources.model.ModelBakery;
+import net.minecraft.client.resources.model.ModelResourceLocation;
+import net.minecraft.client.resources.model.UnbakedModel;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.profiling.ProfilerFiller;
+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(ModelBakery.class)
+public abstract class ModelLoaderMixin {
+
+    @Shadow abstract UnbakedModel getModel(ResourceLocation resourceLocation);
+
+    @Shadow protected abstract void registerModel(ModelResourceLocation modelId, UnbakedModel unbakedModel);
+
+    @Inject(
+        method = "<init>",
+        at = @At("TAIL")
+    )
+    public void init(BlockColors blockColors,
+        ProfilerFiller profiler,
+        Map<ResourceLocation, BlockModel> jsonUnbakedModels,
+        Map<ResourceLocation, List<BlockStateModelLoader.LoadedJson>> blockStates,
+        CallbackInfo ci) {
+        CobblemonBakingOverrides.INSTANCE.getModels().forEach(bakingOverride -> {
+            var unbakedModel = this.getModel(bakingOverride.getModelLocation());
+            this.registerModel(bakingOverride.getModelIdentifier(), unbakedModel);
+        });
+    }
+}

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

@@ -0,0 +1,47 @@
+/*
+ * 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.client;
+
+import com.cobblemon.mod.common.client.render.models.blockbench.pose.Bone;
+import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+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;
+import net.minecraft.client.model.geom.ModelPart;
+
+@Mixin(ModelPart.class)
+public abstract class ModelPartMixin implements Bone {
+    @Shadow public abstract void render(PoseStack matrices, VertexConsumer vertices, int light, int overlay, int color);
+
+    @Shadow public abstract void translateAndRotate(PoseStack 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, PoseStack stack, VertexConsumer buffer, int packedLight, int packedOverlay, int color) {
+        this.render(stack, buffer, packedLight, packedOverlay, color);
+    }
+
+    @Override
+    public void transform(PoseStack matrixStack) {
+        this.translateAndRotate(matrixStack);
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/client/MouseHandlerMixin.java

@@ -0,0 +1,136 @@
+/*
+ * 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.client;
+
+import com.cobblemon.mod.common.Rollable;
+import com.cobblemon.mod.common.client.CobblemonClient;
+import com.cobblemon.mod.common.client.keybind.keybinds.PartySendBinding;
+import com.cobblemon.mod.common.pokedex.scanner.PokedexUsageContext;
+import com.llamalad7.mixinextras.injector.v2.WrapWithCondition;
+import com.llamalad7.mixinextras.sugar.Local;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.MouseHandler;
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.util.Mth;
+import net.minecraft.util.SmoothDouble;
+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;
+
+@Mixin(MouseHandler.class)
+public class MouseHandlerMixin {
+    @Shadow private double accumulatedScrollY;
+    @Shadow @Final private Minecraft minecraft;
+
+    @Unique SmoothDouble pitchSmoother = new SmoothDouble();
+    @Unique SmoothDouble rollSmoother = new SmoothDouble();
+
+    @Shadow @Final private SmoothDouble smoothTurnY;
+
+    @Shadow @Final private SmoothDouble smoothTurnX;
+
+    @Shadow private double accumulatedDX;
+
+    @Shadow private double accumulatedDY;
+
+    @Inject(
+            method = "onScroll",
+            at = @At(
+                    value = "FIELD",
+                    target="Lnet/minecraft/client/MouseHandler;accumulatedScrollY:D",
+                    opcode = Opcodes.PUTFIELD,
+                    ordinal = 2,
+                    shift = At.Shift.BEFORE
+            ),
+            cancellable = true
+    )
+    public void cobblemon$scrollParty(long window, double horizontal, double vertical, CallbackInfo ci) {
+        if (PartySendBinding.INSTANCE.getWasDown()) {
+            int i = (int) accumulatedScrollY;
+            if (i > 0) {
+                accumulatedScrollY -= i;
+                CobblemonClient.INSTANCE.getStorage().shiftSelected(false);
+                ci.cancel();
+                PartySendBinding.INSTANCE.actioned();
+            } else if (i < 0) {
+                accumulatedScrollY -= i;
+                CobblemonClient.INSTANCE.getStorage().shiftSelected(true);
+                ci.cancel();
+                PartySendBinding.INSTANCE.actioned();
+            }
+        }
+    }
+
+    @Inject(
+        method = "onScroll",
+        at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/world/entity/player/Inventory;swapPaint(D)V"
+        ),
+        cancellable = true
+    )
+    public void cobblemon$doPokedexZoom(long window, double horizontal, double vertical, CallbackInfo ci) {
+        PokedexUsageContext usageContext = CobblemonClient.INSTANCE.getPokedexUsageContext();
+        if (usageContext.getScanningGuiOpen()) {
+            usageContext.adjustZoom(vertical);
+            ci.cancel();
+        }
+    }
+
+    @WrapWithCondition(
+            method = "turnPlayer",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/client/player/LocalPlayer;turn(DD)V"
+            )
+    )
+    public boolean cobblemon$modifyRotation(LocalPlayer player, double cursorDeltaX, double cursorDeltaY, @Local(argsOnly = true) double d) {
+        PokedexUsageContext usageContext = CobblemonClient.INSTANCE.getPokedexUsageContext();
+        if (usageContext.getScanningGuiOpen()) {
+            this.smoothTurnY.reset();
+            this.smoothTurnX.reset();
+            var defaultSensitivity = this.minecraft.options.sensitivity().get() * 0.6000000238418579 + 0.20000000298023224;
+            var spyglassSensitivity = Math.pow(defaultSensitivity, 3);
+            var lookSensitivity = spyglassSensitivity * 8.0;
+            var sensitivity = Mth.lerp(usageContext.getFovMultiplier(), spyglassSensitivity, lookSensitivity);
+            player.turn(this.accumulatedDX * sensitivity, (this.accumulatedDY * sensitivity));
+            return false;
+        }
+
+        if (!(player instanceof Rollable rollable)) return true;
+        if (!rollable.shouldRoll()) {
+            pitchSmoother.reset();
+            rollSmoother.reset();
+            return true;
+        }
+
+        var pitch = pitchSmoother.getNewDeltaValue(cursorDeltaY * 0.15f, d);
+        var roll = rollSmoother.getNewDeltaValue(cursorDeltaX * 0.15f, d);
+        rollable.rotate(0.0F, (float)pitch, (float)roll);
+        return false;
+    }
+
+    @Inject(method = "handleAccumulatedMovement", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/MouseHandler;isMouseGrabbed()Z", ordinal = 0))
+    private void cobblemon$maintainMovementWhenInScreens(CallbackInfo ci, @Local(ordinal = 1) double e) {
+        if (minecraft.player == null) return;
+        if (!(minecraft.player instanceof Rollable rollable)) return;
+        if (!rollable.shouldRoll()) return;
+        if (minecraft.isPaused()) return;
+
+        var pitch = pitchSmoother.getNewDeltaValue(0, e);
+        var roll = rollSmoother.getNewDeltaValue(0, e);
+        rollable.rotate(0.0F, (float)pitch, (float)roll);
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/client/PlayerModelMixin.java

@@ -0,0 +1,36 @@
+/*
+ * 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.client;
+import com.cobblemon.mod.common.api.riding.Rideable;
+import com.cobblemon.mod.common.api.riding.RidingManager;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.client.model.PlayerModel;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+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(PlayerModel.class)
+public class PlayerModelMixin {
+    @Inject(method = "setupAnim(Lnet/minecraft/world/entity/LivingEntity;FFFFF)V", at = @At(value = "HEAD"))
+    private void cobblemon$setHeadRotation(LivingEntity entity, float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, CallbackInfo ci){
+        if (!(entity instanceof Player)) return;
+        Entity vehicle = entity.getVehicle();
+
+        if (!(vehicle instanceof PokemonEntity)) return;
+        RidingManager ridingManager = ((Rideable) vehicle).getRiding();
+        if (ridingManager.shouldRotatePlayerHead((PokemonEntity) vehicle)) return;
+
+        netHeadYaw = 0f;
+        headPitch = 0f;
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/client/PlayerRendererMixin.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.client;
+
+import com.cobblemon.mod.common.client.render.ClientPlayerIcon;
+import com.cobblemon.mod.common.client.render.player.MountedPlayerRenderer;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.entity.player.PlayerRenderer;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+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(PlayerRenderer.class)
+public class PlayerRendererMixin {
+    @Inject(method = "render(Lnet/minecraft/world/entity/LivingEntity;FFLcom/mojang/blaze3d/vertex/PoseStack;Lnet/minecraft/client/renderer/MultiBufferSource;I)V", at = @At(value = "TAIL"))
+    public void cobblemon$clientPlayerIcon(LivingEntity entity, float entityYaw, float partialTicks, PoseStack poseStack, MultiBufferSource buffer, int packedLight, CallbackInfo ci) {
+        ClientPlayerIcon.Companion.onRenderPlayer((Player) entity);
+    }
+
+    @Inject(
+            method = "setupRotations(Lnet/minecraft/client/player/AbstractClientPlayer;Lcom/mojang/blaze3d/vertex/PoseStack;FFFF)V",
+            at = @At("HEAD")
+    )
+    private void cobblemon$modifyRoll(AbstractClientPlayer player, PoseStack poseStack, float a, float b, float partialTicks, float i, CallbackInfo ci) {
+        if (player.isPassenger()) {
+            var vehicle = player.getVehicle();
+            if (vehicle instanceof PokemonEntity entity) {
+                MountedPlayerRenderer.INSTANCE.render(player, entity, poseStack, a, b, partialTicks, i);
+            }
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/entity/EntityMixin.java

@@ -0,0 +1,32 @@
+/*
+ * 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.entity;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.world.entity.Entity;
+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(Entity.class)
+public abstract class EntityMixin {
+
+    @Shadow @Nullable public abstract Entity getVehicle();
+
+    @Inject(method = "updateInWaterStateAndDoWaterCurrentPushing", at = @At(value = "FIELD", target = "Lnet/minecraft/world/entity/Entity;wasTouchingWater:Z", ordinal = 1), cancellable = true)
+    public void cobblemon$verifyActuallyTouchingWater(CallbackInfo ci) {
+        if(this.getVehicle() instanceof PokemonEntity) {
+            ci.cancel();
+        }
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/entity/TameableEntityMixin.java

@@ -9,18 +9,18 @@
 package com.cobblemon.mod.common.mixin.entity;
 
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
-import net.minecraft.entity.passive.TameableEntity;
-import net.minecraft.world.World;
+import net.minecraft.world.entity.TamableAnimal;
+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.Redirect;
 
-@Mixin(TameableEntity.class)
+@Mixin(TamableAnimal.class)
 public class TameableEntityMixin {
 
-    @Redirect(method = "onDeath", at = @At(value = "FIELD", target = "Lnet/minecraft/world/World;isClient:Z"))
-    public boolean cobblemon$checkIfPokemonBeforeSendingMessage(World world) {
-        return world.isClient || (this.getClass().isAssignableFrom(PokemonEntity.class));
+    @Redirect(method = "die", at = @At(value = "FIELD", target = "Lnet/minecraft/world/level/Level;isClientSide:Z"))
+    public boolean cobblemon$checkIfPokemonBeforeSendingMessage(Level world) {
+        return world.isClientSide || (this.getClass().isAssignableFrom(PokemonEntity.class));
     }
 
 }

common/src/main/java/com/cobblemon/mod/common/mixin/invoker/AdornRegisterInvoker.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.invoker;
+
+import java.util.List;
+
+import com.cobblemon.mod.common.integration.AdornCompatibility;
+import juuxel.adorn.block.variant.BlockVariantSet;
+import juuxel.adorn.block.variant.BlockVariantSets;
+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;
+
+//This is a yucky hack but better than what we were doing before
+@Mixin(BlockVariantSets.class)
+public abstract class AdornRegisterInvoker {
+    @Final
+    @Shadow(remap = false)
+    private static List<BlockVariantSet> variantSets;
+
+    @Inject(method = "register()V", at = @At("HEAD"), remap = false)
+    private static void register(CallbackInfo ci) {
+        variantSets.add(new AdornCompatibility());
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/invoker/BlocksInvoker.java

@@ -8,9 +8,11 @@
 
 package com.cobblemon.mod.common.mixin.invoker;
 
-import net.minecraft.block.*;
-import net.minecraft.resource.featuretoggle.FeatureFlag;
-import net.minecraft.sound.BlockSoundGroup;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.SoundType;
+import net.minecraft.world.level.block.state.properties.BlockSetType;
+import net.minecraft.world.level.material.MapColor;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.gen.Invoker;
 
@@ -18,24 +20,24 @@ import org.spongepowered.asm.mixin.gen.Invoker;
 @Mixin(Blocks.class)
 public interface BlocksInvoker {
 
-    @Invoker("createLogBlock")
-    static PillarBlock createLogBlock(MapColor topMapColor, MapColor sideMapColor) {
+    @Invoker("log")
+    static Block createLogBlock(MapColor topMapColor, MapColor sideMapColor) {
         throw new UnsupportedOperationException();
     }
 
-    @Invoker("createLeavesBlock")
-    static LeavesBlock createLeavesBlock(BlockSoundGroup soundGroup) {
+    @Invoker("leaves")
+    static Block createLeavesBlock(SoundType soundGroup) {
         throw new UnsupportedOperationException();
     }
 
-    @Invoker("createWoodenButtonBlock")
-    static ButtonBlock createWoodenButtonBlock(BlockSetType blockSetType, FeatureFlag... requiredFeatures) {
+    @Invoker("woodenButton")
+    static Block createWoodenButtonBlock(BlockSetType blockSetType) {
         throw new UnsupportedOperationException();
     }
 
-    @Invoker("createFlowerPotBlock")
-    static FlowerPotBlock createFlowerPotBlock(Block flower, FeatureFlag... requiredFeatures) {
+    @Invoker("flowerPot")
+    static Block createFlowerPotBlock(Block flower) {
         throw new UnsupportedOperationException();
     }
 
-}
+}

common/src/main/java/com/cobblemon/mod/common/mixin/invoker/BooleanRuleInvoker.java

@@ -8,14 +8,14 @@
 
 package com.cobblemon.mod.common.mixin.invoker;
 
-import net.minecraft.world.GameRules;
+import net.minecraft.world.level.GameRules;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.gen.Invoker;
 
-@Mixin(GameRules.BooleanRule.class)
+@Mixin(GameRules.BooleanValue.class)
 public interface BooleanRuleInvoker {
     @Invoker("create")
-    static GameRules.Type<GameRules.BooleanRule> cobblemon$create(boolean initialValue) {
+    static GameRules.Type<GameRules.BooleanValue> cobblemon$create(boolean initialValue) {
         throw new UnsupportedOperationException();
     }
 }

common/src/main/java/com/cobblemon/mod/common/mixin/invoker/ClientPlayNetworkHandlerInvoker.java

@@ -8,13 +8,13 @@
 
 package com.cobblemon.mod.common.mixin.invoker;
 
-import net.minecraft.client.network.ClientPlayNetworkHandler;
-import net.minecraft.entity.Entity;
+import net.minecraft.client.multiplayer.ClientPacketListener;
+import net.minecraft.world.entity.Entity;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.gen.Invoker;
 
-@Mixin(ClientPlayNetworkHandler.class)
+@Mixin(ClientPacketListener.class)
 public interface ClientPlayNetworkHandlerInvoker {
-    @Invoker
+    @Invoker("postAddEntitySoundInstance")
     void callPlaySpawnSound(Entity entity);
 }

common/src/main/java/com/cobblemon/mod/common/mixin/invoker/DoorBlockInvoker.java

@@ -8,17 +8,16 @@
 
 package com.cobblemon.mod.common.mixin.invoker;
 
-import net.minecraft.block.AbstractBlock;
-import net.minecraft.block.BlockSetType;
-import net.minecraft.block.DoorBlock;
-import net.minecraft.sound.SoundEvent;
+import net.minecraft.world.level.block.DoorBlock;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.properties.BlockSetType;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.gen.Invoker;
 
 @Mixin(DoorBlock.class)
 public interface DoorBlockInvoker {
     @Invoker("<init>")
-    static DoorBlock cobblemon$create(AbstractBlock.Settings settings, BlockSetType blockSetType) {
+    static DoorBlock cobblemon$create(BlockSetType blockSetType, BlockBehaviour.Properties settings) {
         throw new UnsupportedOperationException();
     }
-}
+}

common/src/main/java/com/cobblemon/mod/common/mixin/invoker/FireBlockInvoker.java

@@ -0,0 +1,19 @@
+/*
+ * 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.invoker;
+
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.FireBlock;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@Mixin(FireBlock.class)
+public interface FireBlockInvoker {
+    @Invoker("setFlammable") void registerNewFlammableBlock(Block block, int burnChance, int spreadChance);
+}