Added run_command molang function to general query structs and player structs

# Conflicts:
#	common/src/main/kotlin/com/cobblemon/mod/common/CobblemonNetwork.kt
#	common/src/main/kotlin/com/cobblemon/mod/common/entity/pokeball/EmptyPokeBallEntity.kt
#	common/src/main/kotlin/com/cobblemon/mod/common/util/MoLangExtensions.kt

.gitignore

@@ -5,7 +5,8 @@ bin
 .metadata
 .classpath
 .project
-
+/.architectury-transformer/
+common/src/main/resources/assets/cobblemon/showdown
 # idea
 out
 *.ipr
@@ -20,9 +21,22 @@ build
 # other
 eclipse
 run
+runClient
+runServer
 
 # Files from Forge MDK
 forge*changelog.txt
-/src/main/resources/showdown/package-lock.json
-/src/main/resources/showdown/node_modules/
 /showdown/
+/logs/
+.vscode/launch.json
+.vscode
+common/src/main/resources/assets/cobblemon/showdown
+
+# Generated files
+*/generated/resources/*
+/fabric/src/generated/resources/cobblemon-common.accesswidener
+/.ignored/
+common/.fabric
+
+# MacOS
+.DS_Store

.gitlab-ci.yml

@@ -5,33 +5,60 @@ stages:
   - build
   - deploy
 
-#TODO add client reference test process, delete client from sources and see if compilation is successful
+#TODO add client reference test process, search for import com.cobblemon.mod.common.client
 
-build-job:
+build:
   stage: build
+  only:
+    - branches@cable-mc/cobblemon
   script:
-      - export GRADLE_OPTS="-Xmx3G -Xms3G"
-      - chmod +x ./gradlew
-      - ./gradlew build
+    - export GRADLE_OPTS="-Xmx4G -Xms4G"
+    - chmod +x ./gradlew
+    - ./gradlew build
   cache:
     key: "$CI_COMMIT_REF_NAME"
     policy: push
     paths:
-      - build/libs
+      - forge/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"'
+  script:
+    - export GRADLE_OPTS="-Xmx4G -Xms4G"
+    - chmod +x ./gradlew
+    - ./gradlew publish
 
 # Separate step to deploy the artifacts, save Norry the headache of keeping even more shit around
-deploy-job:
+deploy:
   stage: deploy
+  dependencies:
+    - build
   when: manual
   cache:
     key: "$CI_COMMIT_REF_NAME"
     policy: pull
     paths:
-      - build/libs/*
+      - forge/build/libs/*.jar
+      - fabric/build/libs/*.jar
   script: 
     - echo "Collecting artifacts..."
-    - mv build/libs/*.jar ./
+    - mv forge/build/libs/*+*.jar ./
+    - mv fabric/build/libs/*+*.jar ./
+    - for f in *.jar; do mv "$f" "$(echo "$f" | sed s/+/b$CI_PIPELINE_IID+/)"; done
   artifacts:
-    expire_in: 10 days  
+    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

CREDITS.txt

@@ -1,65 +0,0 @@
-Minecraft Forge: Credits/Thank You
-
-Forge is a set of tools and modifications to the Minecraft base game code to assist 
-mod developers in creating new and exciting content. It has been in development for 
-several years now, but I would like to take this time thank a few people who have 
-helped it along it's way.
-
-First, the people who originally created the Forge projects way back in Minecraft 
-alpha. Eloraam of RedPower, and SpaceToad of Buildcraft, without their acceptiance 
-of me taking over the project, who knows what Minecraft modding would be today.
-
-Secondly, someone who has worked with me, and developed some of the core features
-that allow modding to be as functional, and as simple as it is, cpw. For developing
-FML, which stabelized the client and server modding ecosystem. As well as the base
-loading system that allows us to modify Minecraft's code as elegently as possible.
-
-Mezz, who has stepped up as the issue and pull request manager. Helping to keep me
-sane as well as guiding the community into creating better additions to Forge.
-
-Searge, Bspks, Fesh0r, ProfMobious, and all the rest over on the MCP team {of which 
-I am a part}. For creating some of the core tools needed to make Minecraft modding 
-both possible, and as stable as can be.
-  On that note, here is some specific information of the MCP data we use:
-    * Minecraft Coder Pack (MCP) *
-      Forge Mod Loader and Minecraft Forge have permission to distribute and automatically 
-      download components of MCP and distribute MCP data files. This permission is not 
-      transitive and others wishing to redistribute the Minecraft Forge source independently
-      should seek permission of MCP or remove the MCP data files and request their users 
-      to download MCP separately.
-      
-And lastly, the countless community members who have spent time submitting bug reports, 
-pull requests, and just helping out the community in general. Thank you.
-
---LexManos
-
-=========================================================================
-
-This is Forge Mod Loader.
-
-You can find the source code at all times at https://github.com/MinecraftForge/MinecraftForge/tree/1.12.x/src/main/java/net/minecraftforge/fml
-
-This minecraft mod is a clean open source implementation of a mod loader for minecraft servers
-and minecraft clients.
-
-The code is authored by cpw.
-
-It began by partially implementing an API defined by the client side ModLoader, authored by Risugami.
-http://www.minecraftforum.net/topic/75440-
-This support has been dropped as of Minecraft release 1.7, as Risugami no longer maintains ModLoader.
-
-It also contains suggestions and hints and generous helpings of code from LexManos, author of MinecraftForge.
-http://www.minecraftforge.net/
-
-Additionally, it contains an implementation of topological sort based on that 
-published at http://keithschwarz.com/interesting/code/?dir=topological-sort
-
-It also contains code from the Maven project for performing versioned dependency
-resolution. http://maven.apache.org/
-
-It also contains a partial repackaging of the javaxdelta library from http://sourceforge.net/projects/javaxdelta/
-with credit to it's authors.
-
-Forge Mod Loader downloads components from the Minecraft Coder Pack
-(http://mcp.ocean-labs.de/index.php/Main_Page) with kind permission from the MCP team.
-

HEADER

@@ -0,0 +1,5 @@
+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/.

README.md

@@ -1,20 +1,23 @@
-# Pokémon Cobbled
+# Cobblemon
 
-An open-source Pokémon mod written in Kotlin.
+An open-source Pokémon mod for Minecraft Java Edition, written in Kotlin for Fabric and Forge.
 
 ## Getting started
 
-To set up the development workspace, first clone the project and open the build.gradle with Intellij. This will automatically
-put together all the dependencies and project setup.
+To set up the development workspace, first clone the project and open the build.gradle with Intellij. Make sure that you clone it to a folder that has no spaces in its path (for example, C:/Development/Cobblemon Stuff/cobblemon/ is bad) since Architectury Plugin seems to dislike it.
 
-Run `gradlew genIntellijRuns`, and then in Intellij go to your run configurations, and change whichever you plan on
-running to use a Java 16 JRE. runClient is as if you booted up in singleplayer, runServer is a server without a client,
-and runData is for summoning the Eldritch gods or something, idk.
+After it takes ages to load, you should hopefully have runnable configurations of the project in the top right, such as Minecraft Client (:fabric). If not, try running `./gradlew genEclipseRuns`.
+
+Troubleshooting:
+- Try running `./gradlew --refresh-dependencies`
+- Try File -> Invalidate Caches.
+- Try deleting the `.idea` folder in the project root (make sure IntelliJ is closed when you try it).
+- Try completely reclone the thing lmao.
 
 ## Contributing
 
 If you're interested in contributing to the project, you can simply fork the repository and comment on any of the issues 
-[here](https://gitlab.com/cable-mc/pokemon-cobbled/-/issues?scope=all&state=opened&label_name[]=accepted&assignee_id=None).
+[here](https://gitlab.com/cable-mc/cobblemon/-/issues?scope=all&state=opened&label_name[]=accepted&assignee_id=None).
 
 If you want a more involved role in the project, involving branches on the main repository instead of forking and involvement
-in design discussions, add and message Hiroku#4373 on Discord.
+in design discussions, you can either apply in the `application-box` forum of our Discord or add and message Hiroku (`hiroku_dev`) on our Discord here: https://discord.gg/cobblemon.

build.gradle

@@ -1,224 +0,0 @@
-buildscript {
-    ext.kotlin_version = '1.5.31'
-    repositories {
-        // These repositories are only for Gradle plugins, put any other repositories in the repository block further below
-        maven { url = 'https://maven.minecraftforge.net' }
-        maven { url = 'https://maven.parchmentmc.org' }
-        mavenCentral()
-    }
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '5.1.+', changing: true
-        classpath 'org.spongepowered:mixingradle:0.7.+'
-        classpath 'org.parchmentmc:librarian:1.+'
-    }
-}
-
-plugins {
-    id 'com.github.johnrengelman.shadow' version '7.1.0'
-}
-
-println('Java: ' + System.getProperty('java.version') + ' JVM: ' + System.getProperty('java.vm.version') + '(' + System.getProperty('java.vendor') + ') Arch: ' + System.getProperty('os.arch'))
-
-apply plugin: "java"
-apply plugin: "net.minecraftforge.gradle"
-apply plugin: "org.parchmentmc.librarian.forgegradle"
-apply plugin: "kotlin"
-apply plugin: "maven-publish"
-apply plugin: 'org.spongepowered.mixin'
-
-version = '0.0.1'
-group = 'com.cablemc.pokemoncobbled'
-archivesBaseName = 'PokemonCobbled'
-
-minecraft {
-    mappings channel: 'parchment', version: '2021.08.15-1.17.1'
-
-    accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg') // Currently, this location cannot be changed from the default.
-
-    runs {
-        client {
-            workingDirectory project.file('run')
-            property 'forge.logging.markers', 'REGISTRIES'
-            property 'forge.logging.console.level', 'debug'
-            property 'mixin.env.remapRefMap', 'true'
-            property 'mixin.env.refMapRemappingFile', "${buildDir}/createSrgToMcp/output.srg"
-
-            mods {
-                pokemoncobbled {
-                    source sourceSets.main
-                }
-            }
-        }
-
-        server {
-            workingDirectory project.file('run')
-            property 'forge.logging.markers', 'REGISTRIES'
-            property 'forge.logging.console.level', 'debug'
-            property 'mixin.env.remapRefMap', 'true'
-            property 'mixin.env.refMapRemappingFile', "${buildDir}/createSrgToMcp/output.srg"
-
-            mods {
-                pokemoncobbled {
-                    source sourceSets.main
-                }
-            }
-        }
-
-        data {
-            workingDirectory project.file('run')
-            property 'forge.logging.markers', 'REGISTRIES'
-            property 'forge.logging.console.level', 'debug'
-            property 'mixin.env.remapRefMap', 'true'
-            property 'mixin.env.refMapRemappingFile', "${buildDir}/createSrgToMcp/output.srg"
-
-            // Specify the modid for data generation, where to output the resulting resource, and where to look for existing resources.
-            args '--mod', 'pokemoncobbled', '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources/')
-
-            mods {
-                pokemoncobbled {
-                    source sourceSets.main
-                }
-            }
-        }
-    }
-}
-
-configurations {
-    // Create the library configuration, where our non-mod libraries will be added to
-    library
-    // Any dependency in the library configuration will also be added to the implementation configuration
-    implementation.extendsFrom library
-}
-
-// Configure all runs with the following
-minecraft.runs.all {
-    // Set the minecraft_classpath token to the paths of all jars in the library configuration
-    // This is added with the actual Minecraft classpath to get the real classpath information later on
-    lazyToken('minecraft_classpath') {
-        configurations.library.copyRecursive().resolve().collect { it.absolutePath }.join(File.pathSeparator)
-    }
-}
-
-mixin {
-    // Refmaps for each SourceSet
-    add sourceSets.main, 'mixins.pokemoncobbled.refmap.json'
-
-    // Configs to add to runs and jars
-    config 'mixins.pokemoncobbled.json'
-
-    // Specify options for dev run configs
-    debug.verbose = true
-    debug.export = true
-    dumpTargetOnFailure = true
-
-    // Options for the Annotation Processor
-    quiet
-}
-
-repositories {
-    mavenCentral()
-    maven { url "https://repo.codemc.org/repository/maven-public" }
-    maven { url "https://repo.aikar.co/content/groups/aikar/" }
-    maven { url "https://jitpack.io/" }
-    maven {
-        name = 'kotlinforforge'
-        url = 'https://thedarkcolour.github.io/KotlinForForge/'
-    }
-}
-
-dependencies {
-    minecraft 'net.minecraftforge:forge:1.17.1-37.0.103'
-    implementation('thedarkcolour:kotlinforforge:2.0.1')
-    annotationProcessor 'org.spongepowered:mixin:0.8.4:processor'
-
-    // For Showdown
-    shadow 'com.caoccao.javet:javet:1.0.6' // Linux or Windows
-    shadow 'com.caoccao.javet:javet-macos:1.0.6' // Mac OS (x86_64 Only)
-    shadow group: 'commons-io', name: 'commons-io', version: '2.6'
-
-    // For Showdown
-    library 'com.caoccao.javet:javet:1.0.6' // Linux or Windows
-    library 'com.caoccao.javet:javet-macos:1.0.6' // Mac OS (x86_64 Only)
-    library group: 'commons-io', name: 'commons-io', version: '2.6'
-
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.2'
-    testImplementation 'org.junit.jupiter:junit-jupiter-params:5.5.2'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.3.2'
-    testImplementation 'org.mockito:mockito-core:3.3.3'
-    testImplementation 'io.mockk:mockk:1.12.1'
-}
-
-
-// Testing -------------
-test {
-    useJUnitPlatform()
-}
-// ---------------------
-
-jar {
-    manifest {
-        attributes([
-                "Specification-Title"     : "pokemoncobbled",
-                "Specification-Vendor"    : "Cable MC",
-                "Specification-Version"   : "1", // We are version 1 of ourselves
-                "Implementation-Title"    : project.name,
-                "Implementation-Version"  : project.jar.archiveVersion,
-                "Implementation-Vendor"   : "Cable MC",
-                "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
-        ])
-    }
-}
-
-compileKotlin {
-    kotlinOptions.jvmTarget = "16"
-    kotlinOptions.freeCompilerArgs = ["-Xjvm-default=all"]
-}
-
-/*compileJava {
-    options.compilerArgs += ["-parameters"]
-    options.fork = true
-    options.forkOptions.executable = 'javac'
-}*/
-
-// Example configuration to allow publishing using the maven-publish plugin
-// This is the preferred method to reobfuscate your jar file
-jar.finalizedBy('reobfShadowJar')
-
-shadowJar {
-    classifier = null
-    configurations = [project.configurations.shadow]
-    //minimize()
-    exclude "**/module-info.class"
-    exclude "**/NOTICE"
-//    exclude '**/*.kotlin_metadata'
-//    exclude '**/*.kotlin_module'
-//    exclude '**/*.kotlin_builtins'
-    // relocate('kotlin', 'shaded.kotlin4')
-}
-
-reobf {
-    shadowJar {}
-}
-// Mojang ships Java 16 to end users in 1.17+ instead of Java 8 in 1.16 or lower, so your mod should target Java 16.
-java.toolchain.languageVersion = JavaLanguageVersion.of(16)
-
-
-// Include resources generated by data generators.
-sourceSets.main.resources { srcDir 'src/generated/resources' }
-
-// However if you are in a multi-project build, dev time needs unobfed jar files, so you can delay the obfuscation until publishing by doing
-// publish.dependsOn('reobfJar')
-
-publishing {
-    publications {
-        mavenJava(MavenPublication) {
-            artifact jar
-        }
-    }
-    repositories {
-        maven {
-            url "file://${project.projectDir}/mcmodsrepo"
-        }
-    }
-}

build.gradle.kts

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

changelog.txt

@@ -1 +0,0 @@
-- Added shit

common/build.gradle.kts

@@ -0,0 +1,95 @@
+import utilities.isSnapshot
+import utilities.version
+import java.time.OffsetDateTime
+import java.time.ZoneOffset
+import java.time.format.DateTimeFormatter
+
+/*
+ *
+ *  * 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/.
+ *
+ */
+
+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 "2.8.2"
+}
+
+architectury {
+    common("forge", "fabric")
+}
+
+repositories {
+    maven(url = "${rootProject.projectDir}/deps")
+    maven(url = "https://api.modrinth.com/maven")
+    mavenLocal()
+}
+
+dependencies {
+    implementation(libs.bundles.kotlin)
+    modImplementation(libs.fabric.loader)
+    modApi(libs.molang)
+
+    // Integrations
+    compileOnlyApi(libs.jei.api)
+    modCompileOnly(libs.bundles.fabric.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)
+
+    // Data Storage
+    modCompileOnly(libs.bundles.mongo)
+
+    // Unit Testing
+    testImplementation(libs.bundles.unitTesting)
+}
+
+tasks.withType<Test> {
+    useJUnitPlatform()
+    testLogging {
+        setEvents(listOf("failed"))
+        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) }
+            }
+        }
+    }
+}

common/gradle.properties

@@ -0,0 +1 @@
+maven.artifactId = mod

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

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common;
+
+import com.cobblemon.mod.common.entity.npc.NPCEntity;
+import net.minecraft.entity.ai.brain.Brain;
+import net.minecraft.entity.ai.brain.MemoryModuleType;
+import net.minecraft.entity.ai.brain.sensor.Sensor;
+import net.minecraft.entity.ai.brain.sensor.SensorType;
+
+import java.util.Collection;
+
+public class GenericsCheatClass {
+    // For some reason, doing this in the NPCEntity class in Kotlin gives confusing generic errors I could not resolve.
+    public static Brain.Profile<NPCEntity> createNPCBrain(Collection<MemoryModuleType<?>> memories, Collection<SensorType<? extends Sensor<? super NPCEntity>>> sensors) {
+        return Brain.createProfile(memories, sensors);
+    }
+}

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

@@ -0,0 +1,16 @@
+/*
+ * 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.bridges;
+
+import net.minecraft.structure.processor.StructureProcessor;
+
+public interface StructureProcessorListBridge {
+    void append(StructureProcessor processor);
+    void clear();
+}

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

@@ -0,0 +1,70 @@
+/*
+ * 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.client.render.models.blockbench.pose;
+
+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 java.util.Map;
+
+/**
+ * A bone represents a particular joint of a model. Bones are capable of containing child bones identifiable
+ * by a String ideally representing the name of a particular bone.
+ *
+ * This interface is meant to allow projects and sidemods to implement their own rendering logic in reference
+ * to the bones.
+ *
+ * @author Waterpicker
+ * @since 1.4.0
+ */
+
+public interface Bone {
+
+    /**
+     * A map of identifiable names to child bones
+     *
+     * @since 1.4.0
+     */
+    Map<String, Bone> getChildren();
+
+    /**
+     * Renders a particular bone in relation to a particular entity.
+     *
+     * @param context The render context this bone is being drawn for.
+     * @param stack The current [MatrixStack] for the renderer
+     * @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
+     *
+     * @since 1.4.0
+     */
+    void render(
+            RenderContext context,
+            MatrixStack stack,
+            VertexConsumer buffer,
+            int packedLight,
+            int packedOverlay,
+            float r,
+            float g,
+            float b,
+            float a
+    );
+
+    /**
+     * Allows for direct transformation of a bone via a given matrix stack
+     *
+     * @since 1.4.0
+     */
+    void transform(MatrixStack matrixStack);
+}

common/src/main/java/com/cobblemon/mod/common/compat/LambDynamicLightsCompat.java

@@ -0,0 +1,96 @@
+/*
+ * 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.entity.EntityType;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.util.Pair;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Optional;
+
+// 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(
+                        pokemon -> resolvedPokemonLightLevel(pokemon, false),
+                        pokemon -> true
+                )
+        );
+        DynamicLightHandlers.registerDynamicLightHandler(
+                CobblemonEntities.POKEMON,
+                DynamicLightHandler.makeHandler(
+                        pokemon -> resolvedPokemonLightLevel(pokemon, true),
+                        pokemon -> false
+                )
+        );
+
+        // Shouldered Pokémon
+        DynamicLightHandlers.registerDynamicLightHandler(
+                EntityType.PLAYER,
+                DynamicLightHandler.makeHandler(
+                        player -> resolvedShoulderLightLevel(player, false),
+                        player -> true
+                )
+        );
+        DynamicLightHandlers.registerDynamicLightHandler(
+                EntityType.PLAYER,
+                DynamicLightHandler.makeHandler(
+                        player -> resolvedShoulderLightLevel(player, true),
+                        player -> false
+                )
+        );
+    }
+
+    private static int resolvedPokemonLightLevel(PokemonEntity pokemon, boolean underwater) {
+        return extractFormLightLevel(pokemon.getForm(), underwater).orElse(0);
+    }
+
+    private static int resolvedShoulderLightLevel(PlayerEntity player, boolean underwater) {
+        final Pair<PokemonOnShoulderRenderer.ShoulderData, PokemonOnShoulderRenderer.ShoulderData> shoulderDataPair = PokemonOnShoulderRenderer.shoulderDataOf(player);
+        final Optional<Integer> leftLightLevel = extractShoulderLightLevel(shoulderDataPair.getLeft(), underwater);
+        final Optional<Integer> rightLightLevel = extractShoulderLightLevel(shoulderDataPair.getRight(), 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/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.sound.SoundCategory;
+import net.minecraft.util.Identifier;
+import org.jetbrains.annotations.Nullable;
+
+public interface SoundManagerDuck {
+
+    void pauseSounds(@Nullable Identifier id, @Nullable SoundCategory category);
+
+    void resumeSounds(@Nullable Identifier id, @Nullable SoundCategory category);
+}

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

@@ -0,0 +1,25 @@
+/*
+ * 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.client.sound.SoundInstance;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.util.Identifier;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+
+public interface SoundSystemDuck {
+
+    void pauseSounds(@Nullable Identifier id, @Nullable SoundCategory category);
+
+    void resumeSounds(@Nullable Identifier id, @Nullable SoundCategory category);
+
+    Collection<SoundInstance> getSounds(@Nullable SoundCategory category);
+}

common/src/main/java/com/cobblemon/mod/common/mixin/BuiltinModelItemRendererMixin.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;
+
+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 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)
+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) {
+        CobblemonBuiltinItemRenderer renderer = CobblemonBuiltinItemRendererRegistry.INSTANCE.rendererOf(stack.getItem());
+        if (renderer != null) {
+            renderer.render(stack, mode, matrices, vertexConsumers, light, overlay);
+            ci.cancel();
+        }
+    }
+
+}

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.CobblemonBuildDetails;
+import net.minecraft.util.crash.CrashReport;
+import net.minecraft.util.crash.CrashReportSection;
+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 = "addStackTrace", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/SystemDetails;writeTo(Ljava/lang/StringBuilder;)V"))
+    public void cobblemon$printCobblemonDetails(StringBuilder builder, CallbackInfo callback) {
+        CrashReportSection cobblemon = new CrashReportSection("Cobblemon");
+        cobblemon.add("Version", CobblemonBuildDetails.VERSION);
+        cobblemon.add("Is Snapshot", CobblemonBuildDetails.SNAPSHOT);
+        cobblemon.add("Git Commit", CobblemonBuildDetails.INSTANCE.smallCommitHash() + " (" + "https://gitlab.com/cable-mc/cobblemon/-/commit/" + CobblemonBuildDetails.GIT_COMMIT + ")");
+        cobblemon.add("Branch", CobblemonBuildDetails.BRANCH);
+
+        cobblemon.addStackTrace(builder);
+        builder.append("\n\n");
+    }
+
+}

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.sherds.CobblemonSherds;
+import net.minecraft.block.DecoratedPotPatterns;
+import net.minecraft.item.Item;
+import net.minecraft.registry.RegistryKey;
+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 = "fromSherd", at=@At("HEAD"), cancellable = true)
+    private static void cobblemon$getCobblemonSherdTexture(Item sherd,
+        CallbackInfoReturnable<RegistryKey<String>> cir) {
+        if (CobblemonSherds.INSTANCE.getSherdToPattern().containsKey(sherd)) {
+            cir.setReturnValue(CobblemonSherds.INSTANCE.getSherdToPattern().get(sherd));
+            return;
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/EntityRenderDispatcherMixin.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;
+
+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 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(EntityRenderDispatcher.class)
+public class EntityRenderDispatcherMixin {
+
+    @Shadow private Map<String, EntityRenderer<? extends PlayerEntity>> modelRenderers;
+
+    @Inject(
+        method = "reload",
+        at = @At(value = "TAIL")
+    )
+    public void resourceManagerReloadHook(ResourceManager resourceManager, CallbackInfo ci) {
+        CobblemonClient.INSTANCE.onAddLayer(this.modelRenderers);
+    }
+}

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 net.minecraft.entity.passive.VillagerEntity;
+        import net.minecraft.item.ItemStack;
+        import net.minecraft.village.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.CallbackInfoReturnable;
+        import com.cobblemon.mod.common.villager.VillagerGatherableItems;
+
+        import java.util.Objects;
+
+@Mixin(VillagerEntity.class)
+public abstract class EntityVillagerMixin {
+
+    @Inject(method = "canGather", at = @At(value = "RETURN"), cancellable = true)
+    private void cobblemon$canGather(ItemStack stack, CallbackInfoReturnable<Boolean> ci) {
+        final VillagerEntity villager = (VillagerEntity) (Object) this;
+        if(ci.getReturnValue() == false && Objects.equals(villager.getVillagerData().getProfession(), VillagerProfession.FARMER) && villager.getInventory().canInsert(stack)) {
+            if(VillagerGatherableItems.INSTANCE.getVillagerGatherableItems().contains(stack.getItem()))
+                ci.setReturnValue(true);
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+/*
+ * 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.PreEmptsExplosion;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import net.minecraft.world.explosion.Explosion;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+@Mixin(value = Explosion.class)
+public class ExplosionMixin {
+
+    @Redirect(
+            method = "affectWorld",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/world/World;getBlockState(Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/block/BlockState;",
+                    ordinal = 0
+            )
+    )
+    public BlockState cobblemon$whenExploded(World world, BlockPos pos) {
+        BlockState blockState = world.getBlockState(pos);
+        if(blockState.getBlock() instanceof PreEmptsExplosion preExplosionBlock) {
+            preExplosionBlock.whenExploded(world, blockState, pos);
+        }
+        return blockState;
+    }
+}

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.api.scheduling.ClientTaskTracker;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.render.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(float tickDelta, long startTime, boolean tick, CallbackInfo ci) {
+        MinecraftClient client = MinecraftClient.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/LivingEntityMixin.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.api.pokemon.effect.ShoulderEffectRegistry;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.effect.StatusEffectInstance;
+import net.minecraft.server.network.ServerPlayerEntity;
+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(LivingEntity.class)
+public abstract class LivingEntityMixin {
+
+    @Inject(method = "onStatusEffectRemoved", at = @At(value = "TAIL"))
+    private void cobblemon$onStatusEffectRemoved(StatusEffectInstance effect, CallbackInfo ci) {
+        final LivingEntity entity = (LivingEntity) (Object) this;
+        if (entity instanceof ServerPlayerEntity) {
+            ShoulderEffectRegistry.INSTANCE.onEffectEnd((ServerPlayerEntity) entity);
+        }
+    }
+
+}

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.entity.Entity;
+import net.minecraft.server.dedicated.DedicatedServer;
+import net.minecraft.server.world.ServerWorld;
+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 {
+
+    @Inject(method = "shouldCancelSpawn", at = @At(value = "HEAD"), cancellable = true)
+    public void cobblemon$allowPokemonSpawns(Entity entity, CallbackInfoReturnable<Boolean> callback) {
+        if(entity instanceof PokemonEntity) {
+            callback.setReturnValue(false);
+        }
+    }
+
+}

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.client.CobblemonBakingOverrides;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Map;
+import net.minecraft.client.color.block.BlockColors;
+import net.minecraft.client.render.model.ModelLoader;
+import net.minecraft.client.render.model.UnbakedModel;
+import net.minecraft.client.render.model.json.JsonUnbakedModel;
+import net.minecraft.client.util.ModelIdentifier;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.profiler.Profiler;
+import org.slf4j.Logger;
+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.InjectionPoint;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.points.BeforeStringInvoke;
+
+@Mixin(ModelLoader.class)
+public abstract class ModelLoaderMixin {
+
+    @Shadow protected abstract void addModel(ModelIdentifier modelId);
+
+    @Final
+    @Shadow
+    private Map<Identifier, UnbakedModel> unbakedModels;
+
+    @Final
+    @Shadow
+    private static Logger LOGGER;
+
+    @Inject(
+        method = "<init>",
+        at = @At("TAIL")
+    )
+    public void init(BlockColors blockColors,
+        Profiler profiler,
+        Map jsonUnbakedModels,
+        Map blockStates,
+        CallbackInfo ci) {
+        CobblemonBakingOverrides.INSTANCE.getModels().forEach(bakingOverride -> {
+            try {
+                this.unbakedModels.put(bakingOverride.getModelIdentifier(), this.loadModelFromJson(bakingOverride.getModelLocation()));
+                this.addModel(bakingOverride.getModelIdentifier());
+            } catch (IOException e) {
+                LOGGER.error("Error loading a Cobblemon BakedModel:", e);
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    @Shadow
+    private JsonUnbakedModel loadModelFromJson(Identifier id) throws IOException {
+        return null;
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/ModelPartMixin.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;
+
+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/MusicTrackerMixin.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.battle.BattleMusicController;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.sound.MusicTracker;
+import net.minecraft.client.sound.SoundInstance;
+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(MusicTracker.class)
+public class MusicTrackerMixin {
+
+    @Shadow @Final
+    private MinecraftClient client;
+
+    @Shadow @Nullable
+    private SoundInstance current;
+
+    /** 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.client.getSoundManager().isPlaying(BattleMusicController.INSTANCE.getMusic())) cb.cancel();
+    }
+}

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 net.minecraft.client.particle.ParticleManager;
+import net.minecraft.client.particle.ParticleTextureSheet;
+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;
+
+@Mixin(ParticleManager.class)
+final class ParticleManagerMixin {
+    @Mutable
+    @Final
+    @Shadow
+    private static List<ParticleTextureSheet> PARTICLE_TEXTURE_SHEETS;
+
+    @Inject(at = @At("RETURN"), method = "<clinit>")
+    private static void lodestone$addTypes(CallbackInfo ci) {
+        PARTICLE_TEXTURE_SHEETS = ImmutableList.<ParticleTextureSheet>builder().addAll(PARTICLE_TEXTURE_SHEETS)
+                .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

@@ -0,0 +1,53 @@
+/*
+ * 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.entity.mob.PiglinBrain;
+import net.minecraft.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(PiglinBrain.class)
+public class PiglinBarterMixin {
+
+    @Inject(method = "acceptsForBarter", 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.isOf(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.entity.EquipmentSlot;
+import net.minecraft.entity.mob.PiglinEntity;
+import net.minecraft.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(PiglinEntity.class)
+public abstract class PiglinEntityMixin  {
+    @Inject(method = "equipToOffHand", at = @At(value = "HEAD"), cancellable = true)
+    public void cobblemon$isValidBarteringItem(ItemStack stack, CallbackInfo ci) {
+        PiglinEntity entity = (PiglinEntity)(Object) this;
+        if (stack.isOf(CobblemonItems.RELIC_COIN_POUCH)) {
+            entity.equipStack(EquipmentSlot.OFFHAND, stack);
+            entity.updateDropChances(EquipmentSlot.OFFHAND);
+            ci.cancel();
+        }
+    }
+}

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

@@ -0,0 +1,161 @@
+/*
+ * 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.CobblemonItems;
+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.storage.party.PartyStore;
+import com.cobblemon.mod.common.api.tags.CobblemonItemTags;
+import com.cobblemon.mod.common.pokemon.Pokemon;
+import com.cobblemon.mod.common.util.CompoundTagExtensionsKt;
+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.nbt.NbtCompound;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.Text;
+import net.minecraft.world.World;
+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;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.Objects;
+import java.util.UUID;
+
+@Mixin(PlayerEntity.class)
+public abstract class PlayerMixin extends LivingEntity {
+
+    @Shadow public abstract NbtCompound getShoulderEntityLeft();
+
+    @Shadow public abstract NbtCompound getShoulderEntityRight();
+
+    @Shadow public abstract void dropShoulderEntity(NbtCompound entityNbt);
+
+    @Shadow public abstract void setShoulderEntityRight(NbtCompound entityNbt);
+
+    @Shadow public abstract void setShoulderEntityLeft(NbtCompound entityNbt);
+
+    @Shadow public abstract boolean isSpectator();
+
+    @Shadow public abstract boolean giveItemStack(ItemStack stack);
+
+    @Shadow public abstract void sendMessage(Text message, boolean overlay);
+
+
+    protected PlayerMixin(EntityType<? extends LivingEntity> p_20966_, World 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) {
+        if (CompoundTagExtensionsKt.isPokemonEntity(nbt)) {
+            final UUID uuid = this.getPokemonID(nbt);
+            if (this.isShoulderPokemon(this.getShoulderEntityRight())) {
+                final UUID uuidRight = this.getPokemonID(this.getShoulderEntityRight());
+                if (uuid.equals(uuidRight)) {
+                    this.recallPokemon(uuidRight);
+                    this.setShoulderEntityRight(new NbtCompound());
+                }
+            }
+            if (this.isShoulderPokemon(this.getShoulderEntityLeft())) {
+                final UUID uuidLeft = this.getPokemonID(this.getShoulderEntityLeft());
+                if (uuid.equals(uuidLeft)) {
+                    this.recallPokemon(uuidLeft);
+                    this.setShoulderEntityLeft(new NbtCompound());
+                }
+            }
+            ci.cancel();
+        }
+    }
+
+    @Inject(
+        method = "dropShoulderEntities",
+        at = @At(
+            value = "JUMP",
+            opcode = Opcodes.IFGE,
+            ordinal = 0,
+            shift = At.Shift.AFTER
+        ),
+        cancellable = true
+    )
+    private void cobblemon$preventPokemonDropping(CallbackInfo ci) {
+        // We want to allow both of these to forcefully remove the entities
+        if (this.isSpectator() || this.isDead())
+            return;
+        if (!this.isShoulderPokemon(this.getShoulderEntityLeft())) {
+            this.dropShoulderEntity(this.getShoulderEntityLeft());
+            this.setShoulderEntityLeft(new NbtCompound());
+        }
+        if (!this.isShoulderPokemon(this.getShoulderEntityRight())) {
+            this.dropShoulderEntity(this.getShoulderEntityRight());
+            this.setShoulderEntityRight(new NbtCompound());
+        }
+        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();
+                }
+            }
+        } catch (NoPokemonStoreException ignored) {}
+    }
+
+    private boolean isShoulderPokemon(NbtCompound nbt) {
+        return CompoundTagExtensionsKt.isPokemonEntity(nbt);
+    }
+
+    @Inject(
+        method = "eatFood",
+        at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/entity/player/PlayerEntity;getHungerManager()Lnet/minecraft/entity/player/HungerManager;",
+            shift = At.Shift.AFTER
+        )
+    )
+    public void onEatFood(World world, ItemStack stack, CallbackInfoReturnable<ItemStack> cir) {
+        if (!getWorld().isClient) {
+            if (stack.isIn(CobblemonItemTags.LEAVES_LEFTOVERS) && getWorld().random.nextDouble() < Cobblemon.config.getAppleLeftoversChance()) {
+                ItemStack leftovers = new ItemStack(CobblemonItems.LEFTOVERS);
+                ServerPlayerEntity player = Objects.requireNonNull(getServer()).getPlayerManager().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()));
+                        }
+                        return null;
+                    }
+                );
+            }
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/PointedDripstoneBlockMixin.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;
+
+import com.cobblemon.mod.common.api.tags.CobblemonBlockTags;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.PointedDripstoneBlock;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.Slice;
+
+@Mixin(PointedDripstoneBlock.class)
+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;"))
+    )
+    private static boolean cobblemon$validateMoonStoneDripstone(BlockState instance, Block block) {
+        return instance.isIn(CobblemonBlockTags.DRIPSTONE_GROWABLE);
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/ShearsDispenserBehaviorMixin.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.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 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)
+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) {
+        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/SoundManagerMixin.java

@@ -0,0 +1,84 @@
+/*
+ * 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.battle.BattleMusicController;
+import com.cobblemon.mod.common.duck.SoundManagerDuck;
+import com.cobblemon.mod.common.duck.SoundSystemDuck;
+import net.minecraft.client.sound.*;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.util.Identifier;
+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 abstract class SoundManagerMixin implements SoundManagerDuck {
+
+    @Shadow
+    public abstract boolean isPlaying(SoundInstance sound);
+
+    @Shadow @Final
+    private SoundSystem soundSystem;
+
+    // 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 BiomeEffectSoundPlayer.MusicLoop || sound instanceof AmbientSoundLoops.Underwater;
+    }
+
+    private boolean filterCondition(SoundInstance sound) {
+        return !isAmbientLoop(sound) &&
+            this.isPlaying(BattleMusicController.INSTANCE.getMusic()) &&
+                BattleMusicController.INSTANCE.getFilteredCategories().contains(sound.getCategory());
+    }
+
+    private boolean ambientLoopCondition(SoundInstance sound) {
+        return isAmbientLoop(sound) &&
+            this.isPlaying(BattleMusicController.INSTANCE.getMusic()) &&
+                BattleMusicController.INSTANCE.getFilteredCategories().contains(sound.getCategory());
+    }
+
+    /** Pauses the queried SoundInstance(s). If id is null, will pause all sounds belonging to the SoundCategory. */
+    @Override
+    public void pauseSounds(@Nullable Identifier id, @Nullable SoundCategory category) {
+        ((SoundSystemDuck)soundSystem).pauseSounds(id, category);
+    }
+
+    /** Resumes the queried SoundInstance(s). If id is null, will resume all sounds belonging to the SoundCategory. */
+    @Override
+    public void resumeSounds(@Nullable Identifier id, @Nullable SoundCategory category) {
+        ((SoundSystemDuck)soundSystem).resumeSounds(id, category);
+    }
+
+    /** Blocks filtered sounds from being played while a BattleMusicInstance is in progress. */
+    @Inject(method = "play(Lnet/minecraft/client/sound/SoundInstance;)V", at = @At("HEAD"), cancellable = true)
+    public void playStart(SoundInstance sound, CallbackInfo cb) {
+        if (filterCondition(sound)) cb.cancel();
+    }
+
+    @Inject(method = "play(Lnet/minecraft/client/sound/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/sound/SoundInstance;)V", at = @At("TAIL"))
+    public void playEnd(SoundInstance sound, CallbackInfo cb) {
+        if (ambientLoopCondition(sound)) this.pauseSounds(sound.getId(), SoundCategory.AMBIENT);
+    }
+
+    @Inject(method = "play(Lnet/minecraft/client/sound/SoundInstance;I)V", at = @At("TAIL"))
+    public void playEnd(SoundInstance sound, int delay, CallbackInfo cb) {
+        if (ambientLoopCondition(sound)) this.pauseSounds(sound.getId(), SoundCategory.AMBIENT);
+    }
+}

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

@@ -0,0 +1,110 @@
+/*
+ * 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.battle.BattleMusicController;
+import com.cobblemon.mod.common.duck.SoundSystemDuck;
+import com.google.common.collect.Multimap;
+import net.minecraft.client.sound.*;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.util.Identifier;
+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(SoundSystem.class)
+public abstract class SoundSystemMixin implements SoundSystemDuck {
+
+    @Shadow
+    private boolean started;
+
+    @Shadow
+    private Multimap<SoundCategory, SoundInstance> sounds;
+
+    @Shadow @Final
+    private Map<SoundInstance, Channel.SourceManager> sources;
+
+    @Shadow
+    protected abstract void stop(SoundInstance sound);
+
+    @Shadow
+    public abstract boolean isPlaying(SoundInstance sound);
+
+    /** Resumes the Source belonging to the queried SoundInstance. */
+    private void resume(SoundInstance sound) {
+        Channel.SourceManager sourceManager = this.sources.get(sound);
+        if (this.started && sourceManager != null) sourceManager.run(Source::resume);
+    }
+
+    /** Pauses the Source belonging to the queried SoundInstance. */
+    private void pause(SoundInstance sound) {
+        Channel.SourceManager sourceManager = this.sources.get(sound);
+        if (this.started && sourceManager != null) sourceManager.run(Source::pause);
+    }
+
+    /** Resumes the SoundInstance(s) queried by id and/or category. */
+    @Override
+    public void resumeSounds(@Nullable Identifier id, @Nullable SoundCategory category) {
+        if (category != null) {
+            this.sounds.get(category).forEach((sound) -> {
+                if (id == null || sound.getId().equals(id)) resume(sound);
+            });
+        } else if (id == null) {
+            this.sources.keySet().forEach(this::resume);
+        } else {
+            this.sources.keySet().forEach(sound -> {
+                if (sound.getId().equals(id)) resume(sound);
+            });
+        }
+    }
+
+    /** Pauses the SoundInstances queried by id and/or category. */
+    @Override
+    public void pauseSounds(@Nullable Identifier id, @Nullable SoundCategory category) {
+        if (category != null) {
+            this.sounds.get(category).forEach((sound) -> {
+                if (id == null || sound.getId().equals(id)) pause(sound);
+            });
+        } else if (id == null) {
+            this.sources.keySet().forEach(this::pause);
+        } else {
+            this.sources.keySet().forEach(sound -> {
+                if (sound.getId().equals(id)) pause(sound);
+            });
+        }
+    }
+
+    /** Allows stopping all SoundInstances that belong to a queried category. */
+    @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) {
+            this.sounds.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 = "resumeAll()V", at = @At("HEAD"), cancellable = true)
+    public void resumeAll(CallbackInfo cb) {
+        if (this.isPlaying(BattleMusicController.INSTANCE.getMusic())) {
+            this.sounds.values().forEach(sound -> {
+               if (sound == BattleMusicController.INSTANCE.getMusic() || !BattleMusicController.INSTANCE.getFilteredCategories().contains(sound.getCategory())) {
+                   resume(sound);
+               }
+            });
+            cb.cancel();
+        }
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/StructurePoolAccessor.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;
+
+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;
+
+@Mixin(StructurePool.class)
+public interface StructurePoolAccessor {
+    @Accessor("elementCounts")
+    List<Pair<StructurePoolElement, Integer>> getElementCounts();
+
+    @Mutable
+    @Accessor("elementCounts")
+    void setElementCounts(List<Pair<StructurePoolElement, Integer>> elementCounts);
+
+    @Accessor("elements")
+    ObjectArrayList<StructurePoolElement> getElements();
+}

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

@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.world.CobblemonStructureIDs;
+import 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 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 java.util.*;
+
+@Mixin(StructurePoolBasedGenerator.StructurePoolGenerator.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<>();
+    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.SAVANNA_BERRY_SMALL, Set.of(berry));
+        structureGroups.put(CobblemonStructureIDs.SAVANNA_BERRY_LARGE, Set.of(berry));
+        structureGroups.put(CobblemonStructureIDs.PLAINS_BERRY_SMALL, Set.of(berry));
+        structureGroups.put(CobblemonStructureIDs.PLAINS_BERRY_LARGE, Set.of(berry));
+        structureGroups.put(CobblemonStructureIDs.SNOWY_BERRY_SMALL, Set.of(berry));
+        structureGroups.put(CobblemonStructureIDs.SNOWY_BERRY_LARGE, Set.of(berry));
+        structureGroups.put(CobblemonStructureIDs.DESERT_BERRY_SMALL, Set.of(berry));
+        structureGroups.put(CobblemonStructureIDs.DESERT_BERRY_LARGE, Set.of(berry));
+        structureGroups.put(CobblemonStructureIDs.TAIGA_BERRY_SMALL, Set.of(berry));
+        structureGroups.put(CobblemonStructureIDs.TAIGA_BERRY_LARGE, Set.of(berry));
+
+        //Mapped using location string as key
+        Map<String, Integer> aMap = new HashMap<>();
+        aMap.put(pokecenter, 1);
+        aMap.put(berry, 2);
+
+//        aMap.put(CobblemonStructureIDs.PLAINS_LONG_PATH, 3);
+//        aMap.put(CobblemonStructureIDs.DESERT_LONG_PATH, 3);
+//        aMap.put(CobblemonStructureIDs.SAVANNA_LONG_PATH, 3);
+//        aMap.put(CobblemonStructureIDs.SNOWY_LONG_PATH, 3);
+//        aMap.put(CobblemonStructureIDs.TAIGA_LONG_PATH, 3);
+        structureMaxes = Collections.unmodifiableMap(aMap);
+    }
+
+    public Set<String> getGroups(Identifier structureIdentifier) {
+        return structureGroups.getOrDefault(structureIdentifier, Set.of());
+    }
+
+    public boolean hasReachedMaximum(Identifier structureIdentifier) {
+        Set<String> groups = getGroups(structureIdentifier);
+        for (String group : groups) {
+            int count = generatedStructureGroupCounts.getOrDefault(group, 0);
+            if (count >= structureMaxes.getOrDefault(group, Integer.MAX_VALUE)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public void incrementStructureCount(Identifier structureIdentifier) {
+        Set<String> groups = getGroups(structureIdentifier);
+        for (String group : groups) {
+            generatedStructureGroupCounts.put(group, generatedStructureGroupCounts.getOrDefault(group, 0) + 1);
+        }
+    }
+
+    @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) {
+        generatedStructureGroupCounts = new HashMap<>();
+    }
+
+    @ModifyVariable(method = "generatePiece", 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);
+            if (structurePieceLocationKey == null) {
+                reducedList.add(structure);
+                continue;
+            }
+
+            if (!hasReachedMaximum(structurePieceLocationKey)) {
+                reducedList.add(structure);
+            }
+        }
+
+        return reducedList.iterator();
+    }
+
+    @ModifyVariable(method = "generatePiece", at = @At("STORE"), ordinal = 1)
+    private PoolStructurePiece injected(PoolStructurePiece poolStructurePiece) {
+        Identifier structureLocationKey = getCobblemonOnlyLocation(poolStructurePiece.getPoolElement());
+        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);
+        if (location == null) return null;
+
+        if (!location.getNamespace().equals("cobblemon")) return null;
+
+        return location;
+    }
+
+    private static Identifier getLocationIfAvailable(StructurePoolElement structurePoolElement) {
+        if (structurePoolElement instanceof LegacySinglePoolElement legacySinglePoolElement) {
+            if (legacySinglePoolElement.location.left().isEmpty()) return null;
+
+            return legacySinglePoolElement.location.left().get();
+        } else if (structurePoolElement instanceof SinglePoolElement singlePoolElement) {
+            if (singlePoolElement.location.left().isEmpty()) return null;
+
+            return singlePoolElement.location.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

@@ -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;
+
+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 org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.Shadow;
+
+@Mixin(StructureProcessorList.class)
+public class StructureProcessorListMixin implements StructureProcessorListBridge {
+
+    @Final
+    @Mutable
+    @Shadow
+    private List<StructureProcessor> list;
+
+    @Override
+    public void append(StructureProcessor processor) {
+        List<StructureProcessor> mutable = new ArrayList<>(this.list);
+        mutable.add(processor);
+        this.list = ImmutableList.copyOf(mutable);
+    }
+
+    @Override
+    public void clear() {
+        this.list = ImmutableList.of();
+    }
+
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/AccessorEntity.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.mixin.accessor;
+
+import net.minecraft.entity.Entity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(Entity.class)
+public interface AccessorEntity {
+
+    @Accessor("standingEyeHeight")
+    void standingEyeHeight(float standingEyeHeight);
+
+}

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.entity.vehicle.BoatEntity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(BoatEntity.class)
+public interface BoatEntityAccessor {
+
+    @Accessor
+    void setFallVelocity(double fallVelocity);
+
+    @Accessor
+    BoatEntity.Location getLocation();
+}

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

@@ -0,0 +1,22 @@
+/*
+ * 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.option.KeyBinding;
+import net.minecraft.client.util.InputUtil;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(KeyBinding.class)
+public interface KeyBindingAccessor {
+
+    @Accessor("boundKey")
+    InputUtil.Key boundKey();
+
+}

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

@@ -0,0 +1,26 @@
+/*
+ * 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.entity.effect.StatusEffectInstance;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(StatusEffectInstance.class)
+public interface StatusEffectInstanceAccessor {
+
+    @Accessor
+    void setAmplifier(int amplifier);
+
+    @Accessor
+    void setShowParticles(boolean showParticles);
+
+    @Accessor
+    void setShowIcon(boolean showIcon);
+}

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

@@ -0,0 +1,26 @@
+/*
+ * 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.entity.passive.TameableEntity;
+import net.minecraft.world.World;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+@Mixin(TameableEntity.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));
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/invoker/AdornRegisterInvoker.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.invoker;
+
+import com.cobblemon.mod.common.integration.adorn.AdornCompatibility;
+import java.util.List;
+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)
+    void register(CallbackInfo ci) {
+        variantSets.add(AdornCompatibility.INSTANCE);
+    }
+}

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

@@ -0,0 +1,41 @@
+/*
+ * 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.block.*;
+import net.minecraft.resource.featuretoggle.FeatureFlag;
+import net.minecraft.sound.BlockSoundGroup;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@SuppressWarnings("unused")
+@Mixin(Blocks.class)
+public interface BlocksInvoker {
+
+    @Invoker("createLogBlock")
+    static PillarBlock createLogBlock(MapColor topMapColor, MapColor sideMapColor) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Invoker("createLeavesBlock")
+    static LeavesBlock createLeavesBlock(BlockSoundGroup soundGroup) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Invoker("createWoodenButtonBlock")
+    static ButtonBlock createWoodenButtonBlock(BlockSetType blockSetType, FeatureFlag... requiredFeatures) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Invoker("createFlowerPotBlock")
+    static FlowerPotBlock createFlowerPotBlock(Block flower, FeatureFlag... requiredFeatures) {
+        throw new UnsupportedOperationException();
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/invoker/BooleanRuleInvoker.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.mixin.invoker;
+
+import net.minecraft.world.GameRules;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@Mixin(GameRules.BooleanRule.class)
+public interface BooleanRuleInvoker {
+    @Invoker("create")
+    static GameRules.Type<GameRules.BooleanRule> cobblemon$create(boolean initialValue) {
+        throw new UnsupportedOperationException();
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/invoker/ClientPlayNetworkHandlerInvoker.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.mixin.invoker;
+
+import net.minecraft.client.network.ClientPlayNetworkHandler;
+import net.minecraft.entity.Entity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@Mixin(ClientPlayNetworkHandler.class)
+public interface ClientPlayNetworkHandlerInvoker {
+    @Invoker
+    void callPlaySpawnSound(Entity entity);
+}

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

@@ -0,0 +1,24 @@
+/*
+ * 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.block.AbstractBlock;
+import net.minecraft.block.BlockSetType;
+import net.minecraft.block.DoorBlock;
+import net.minecraft.sound.SoundEvent;
+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) {
+        throw new UnsupportedOperationException();
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/invoker/FireBlockInvoker.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.mixin.invoker;
+
+import net.minecraft.block.Block;
+import org.spongepowered.asm.mixin.Mixin;
+import net.minecraft.block.FireBlock;
+import net.minecraft.block.Blocks;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@Mixin(FireBlock.class)
+public interface FireBlockInvoker {
+    @Invoker("registerFlammableBlock") void registerNewFlammableBlock(Block block, int burnChance, int spreadChance);
+}

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

@@ -0,0 +1,24 @@
+/*
+ * 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.block.AbstractBlock;
+import net.minecraft.block.BlockSetType;
+import net.minecraft.block.PressurePlateBlock;
+import net.minecraft.sound.SoundEvent;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@Mixin(PressurePlateBlock.class)
+public interface PressurePlateBlockInvoker {
+    @Invoker("<init>")
+    static PressurePlateBlock cobblemon$create(PressurePlateBlock.ActivationRule type, AbstractBlock.Settings settings, BlockSetType blockSetType) {
+        throw new UnsupportedOperationException();
+    }
+}

common/src/main/java/com/cobblemon/mod/common/mixin/invoker/StairsBlockInvoker.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.invoker;
+
+import net.minecraft.block.AbstractBlock;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.StairsBlock;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@Mixin(StairsBlock.class)
+public interface StairsBlockInvoker {
+    @Invoker("<init>")
+    static StairsBlock cobblemon$create(BlockState baseBlockState, AbstractBlock.Settings settings) {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,24 @@
+/*
+ * 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.block.AbstractBlock;
+import net.minecraft.block.BlockSetType;
+import net.minecraft.block.TrapdoorBlock;
+import net.minecraft.sound.SoundEvent;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@Mixin(TrapdoorBlock.class)
+public interface TrapdoorBlockInvoker {
+    @Invoker("<init>")
+    static TrapdoorBlock cobblemon$create(AbstractBlock.Settings settings, BlockSetType blockSetType) {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,65 @@
+/*
+ * 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.pokeball;
+
+import com.cobblemon.mod.common.item.PokeBallItem;
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.item.ItemModels;
+import net.minecraft.client.render.item.ItemRenderer;
+import net.minecraft.client.render.model.BakedModel;
+import net.minecraft.client.render.model.json.ModelTransformation;
+import net.minecraft.client.render.model.json.ModelTransformationMode;
+import net.minecraft.client.util.ModelIdentifier;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.world.ClientWorld;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+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 org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(ItemRenderer.class)
+public abstract class ItemRendererMixin {
+
+    @Shadow @Final private ItemModels models;
+
+    @Shadow public abstract void renderItem(ItemStack stack, ModelTransformationMode renderMode, boolean leftHanded, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay, BakedModel model);
+
+    @Inject(method = "getModel", at = @At("HEAD"), cancellable = true)
+    private void cobblemon$bakePokeballModel(ItemStack stack, World world, LivingEntity entity, int seed, CallbackInfoReturnable<BakedModel> cir) {
+        if (stack.getItem() instanceof PokeBallItem pokeBallItem) {
+            BakedModel model = this.models.getModelManager().getModel(new ModelIdentifier(pokeBallItem.getPokeBall().getModel3d(), "inventory"));
+            ClientWorld clientWorld = world instanceof ClientWorld ? (ClientWorld) world : null;
+            BakedModel overriddenModel = model.getOverrides().apply(model, stack, clientWorld, entity, seed);
+            cir.setReturnValue(overriddenModel == null ? this.models.getModelManager().getMissingModel() : overriddenModel);
+        }
+    }
+
+    @Inject(
+            method = "renderItem(Lnet/minecraft/item/ItemStack;Lnet/minecraft/client/render/model/json/ModelTransformationMode;ZLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;IILnet/minecraft/client/render/model/BakedModel;)V",
+            at = @At("HEAD"),
+            cancellable = true
+    )
+    private void cobblemon$determinePokeballModel(ItemStack stack, ModelTransformationMode renderMode, boolean leftHanded, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay, BakedModel model, CallbackInfo ci) {
+        boolean shouldBe2d = renderMode == ModelTransformationMode.GUI || renderMode == ModelTransformationMode.FIXED;
+        if (shouldBe2d && stack.getItem() instanceof PokeBallItem pokeBallItem) {
+            BakedModel replacementModel = this.models.getModelManager().getModel(new ModelIdentifier(pokeBallItem.getPokeBall().getModel2d(), "inventory"));
+            if (!model.equals(replacementModel)) {
+                ci.cancel();
+                renderItem(stack, renderMode, leftHanded, matrices, vertexConsumers, light, overlay, replacementModel);
+            }
+        }
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/pokeball/ThrownEntityMixin.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin.pokeball;
+
+import com.cobblemon.mod.common.entity.pokeball.WaterDragModifier;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.projectile.thrown.ThrownEntity;
+import net.minecraft.world.World;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.ModifyVariable;
+
+@Mixin(ThrownEntity.class)
+public abstract class ThrownEntityMixin extends Entity {
+
+    public ThrownEntityMixin(EntityType<?> type, World world) {
+        super(type, world);
+    }
+
+    @ModifyVariable(method = "tick", at = @At("STORE"), ordinal = 0)
+    private float cobblemon$waterDragModifier(float value) {
+        if (this.isTouchingWater() && this instanceof WaterDragModifier) {
+            return ((WaterDragModifier) this).waterDrag();
+        }
+        return value;
+    }
+
+}

common/src/main/kotlin-templates/CobblemonBuildDetails.kt.peb

@@ -0,0 +1,17 @@
+{{ license }}
+
+package com.cobblemon.mod.common
+
+object CobblemonBuildDetails {
+
+    const val MOD_ID = "{{ modid }}"
+    const val VERSION = "{{ version }}"
+    const val SNAPSHOT = {{ isSnapshot }}
+
+    const val GIT_COMMIT = "{{ gitCommit | default("Not Specified") }}"
+    const val BRANCH = "{{ branch | default("Not Specified") }}"
+
+    fun smallCommitHash(): String {
+        return this.GIT_COMMIT.substring(0, 7)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/BakingOverride.kt

@@ -0,0 +1,29 @@
+/*
+ * 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.client.MinecraftClient
+import net.minecraft.client.render.model.BakedModel
+import net.minecraft.client.util.ModelIdentifier
+import net.minecraft.util.Identifier
+
+/**
+ * Contains information for forcing a model to be baked
+ *
+ * @param modelLocation The location of the model
+ * @param modelIdentifier The identifier that the BakedModel will be registered to
+ */
+data class BakingOverride(
+    val modelLocation: Identifier,
+    val modelIdentifier: ModelIdentifier
+) {
+    fun getModel(): BakedModel {
+        return MinecraftClient.getInstance().bakedModelManager.getModel(modelIdentifier)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/Cobblemon.kt

@@ -0,0 +1,536 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.CobblemonBuildDetails.smallCommitHash
+import com.cobblemon.mod.common.advancement.CobblemonCriteria
+import com.cobblemon.mod.common.advancement.criterion.EvolvePokemonContext
+import com.cobblemon.mod.common.api.Priority
+import com.cobblemon.mod.common.api.SeasonResolver
+import com.cobblemon.mod.common.api.data.DataProvider
+import com.cobblemon.mod.common.api.drop.CommandDropEntry
+import com.cobblemon.mod.common.api.drop.DropEntry
+import com.cobblemon.mod.common.api.drop.ItemDropEntry
+import com.cobblemon.mod.common.api.events.CobblemonEvents
+import com.cobblemon.mod.common.api.events.CobblemonEvents.BATTLE_VICTORY
+import com.cobblemon.mod.common.api.events.CobblemonEvents.DATA_SYNCHRONIZED
+import com.cobblemon.mod.common.api.events.CobblemonEvents.EVOLUTION_COMPLETE
+import com.cobblemon.mod.common.api.events.CobblemonEvents.LEVEL_UP_EVENT
+import com.cobblemon.mod.common.api.events.CobblemonEvents.POKEMON_CAPTURED
+import com.cobblemon.mod.common.api.events.CobblemonEvents.TRADE_COMPLETED
+import com.cobblemon.mod.common.api.net.serializers.IdentifierDataSerializer
+import com.cobblemon.mod.common.api.net.serializers.PoseTypeDataSerializer
+import com.cobblemon.mod.common.api.net.serializers.StringSetDataSerializer
+import com.cobblemon.mod.common.api.net.serializers.UUIDSetDataSerializer
+import com.cobblemon.mod.common.api.net.serializers.Vec3DataSerializer
+import com.cobblemon.mod.common.api.permission.PermissionValidator
+import com.cobblemon.mod.common.api.pokeball.catching.calculators.CaptureCalculator
+import com.cobblemon.mod.common.api.pokeball.catching.calculators.CaptureCalculators
+import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
+import com.cobblemon.mod.common.api.pokemon.effect.ShoulderEffectRegistry
+import com.cobblemon.mod.common.api.pokemon.experience.ExperienceCalculator
+import com.cobblemon.mod.common.api.pokemon.experience.ExperienceGroups
+import com.cobblemon.mod.common.api.pokemon.experience.StandardExperienceCalculator
+import com.cobblemon.mod.common.api.pokemon.feature.ChoiceSpeciesFeatureProvider
+import com.cobblemon.mod.common.api.pokemon.feature.FlagSpeciesFeatureProvider
+import com.cobblemon.mod.common.api.pokemon.feature.IntSpeciesFeatureProvider
+import com.cobblemon.mod.common.api.pokemon.feature.SpeciesFeatures
+import com.cobblemon.mod.common.api.pokemon.helditem.HeldItemProvider
+import com.cobblemon.mod.common.api.pokemon.stats.EvCalculator
+import com.cobblemon.mod.common.api.pokemon.stats.Generation8EvCalculator
+import com.cobblemon.mod.common.api.pokemon.stats.StatProvider
+import com.cobblemon.mod.common.api.properties.CustomPokemonProperty
+import com.cobblemon.mod.common.api.scheduling.ServerRealTimeTaskTracker
+import com.cobblemon.mod.common.api.scheduling.ServerTaskTracker
+import com.cobblemon.mod.common.api.spawning.BestSpawner
+import com.cobblemon.mod.common.api.spawning.CobblemonSpawningProspector
+import com.cobblemon.mod.common.api.spawning.WorldSlice
+import com.cobblemon.mod.common.api.spawning.context.AreaContextResolver
+import com.cobblemon.mod.common.api.spawning.context.AreaSpawningContext
+import com.cobblemon.mod.common.api.spawning.context.calculators.AreaSpawningContextCalculator
+import com.cobblemon.mod.common.api.spawning.context.calculators.AreaSpawningInput
+import com.cobblemon.mod.common.api.spawning.prospecting.SpawningProspector
+import com.cobblemon.mod.common.api.spawning.spawner.Spawner
+import com.cobblemon.mod.common.api.starter.StarterHandler
+import com.cobblemon.mod.common.api.storage.PokemonStoreManager
+import com.cobblemon.mod.common.api.storage.adapter.conversions.ReforgedConversion
+import com.cobblemon.mod.common.api.storage.adapter.database.MongoDBStoreAdapter
+import com.cobblemon.mod.common.api.storage.adapter.flatfile.FileStoreAdapter
+import com.cobblemon.mod.common.api.storage.adapter.flatfile.JSONStoreAdapter
+import com.cobblemon.mod.common.api.storage.adapter.flatfile.NBTStoreAdapter
+import com.cobblemon.mod.common.api.storage.factory.FileBackedPokemonStoreFactory
+import com.cobblemon.mod.common.api.storage.molang.NbtMoLangDataStoreFactory
+import com.cobblemon.mod.common.api.storage.pc.PCStore
+import com.cobblemon.mod.common.api.storage.pc.link.PCLinkManager
+import com.cobblemon.mod.common.api.storage.player.PlayerDataStoreManager
+import com.cobblemon.mod.common.api.storage.player.factory.JsonPlayerDataStoreFactory
+import com.cobblemon.mod.common.api.storage.player.factory.MongoPlayerDataStoreFactory
+import com.cobblemon.mod.common.api.tags.CobblemonEntityTypeTags
+import com.cobblemon.mod.common.api.tags.CobblemonItemTags
+import com.cobblemon.mod.common.battles.BagItems
+import com.cobblemon.mod.common.battles.BattleFormat
+import com.cobblemon.mod.common.battles.BattleRegistry
+import com.cobblemon.mod.common.battles.BattleSide
+import com.cobblemon.mod.common.battles.ShowdownThread
+import com.cobblemon.mod.common.battles.actor.PokemonBattleActor
+import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
+import com.cobblemon.mod.common.command.argument.DialogueArgumentType
+import com.cobblemon.mod.common.command.argument.MoveArgumentType
+import com.cobblemon.mod.common.command.argument.PartySlotArgumentType
+import com.cobblemon.mod.common.command.argument.PokemonArgumentType
+import com.cobblemon.mod.common.command.argument.PokemonPropertiesArgumentType
+import com.cobblemon.mod.common.command.argument.PokemonStoreArgumentType
+import com.cobblemon.mod.common.command.argument.SpawnBucketArgumentType
+import com.cobblemon.mod.common.config.CobblemonConfig
+import com.cobblemon.mod.common.config.LastChangedVersion
+import com.cobblemon.mod.common.config.constraint.IntConstraint
+import com.cobblemon.mod.common.config.starter.StarterConfig
+import com.cobblemon.mod.common.data.CobblemonDataProvider
+import com.cobblemon.mod.common.events.AdvancementHandler
+import com.cobblemon.mod.common.events.FlowHandler
+import com.cobblemon.mod.common.events.ServerTickHandler
+import com.cobblemon.mod.common.item.PokeBallItem
+import com.cobblemon.mod.common.net.messages.client.settings.ServerSettingsPacket
+import com.cobblemon.mod.common.permission.LaxPermissionValidator
+import com.cobblemon.mod.common.platform.events.PlatformEvents
+import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.pokemon.aspects.GENDER_ASPECT
+import com.cobblemon.mod.common.pokemon.aspects.SHINY_ASPECT
+import com.cobblemon.mod.common.pokemon.evolution.variants.BlockClickEvolution
+import com.cobblemon.mod.common.pokemon.feature.TagSeasonResolver
+import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
+import com.cobblemon.mod.common.pokemon.properties.AspectPropertyType
+import com.cobblemon.mod.common.pokemon.properties.HiddenAbilityPropertyType
+import com.cobblemon.mod.common.pokemon.properties.UnaspectPropertyType
+import com.cobblemon.mod.common.pokemon.properties.UncatchableProperty
+import com.cobblemon.mod.common.pokemon.properties.tags.PokemonFlagProperty
+import com.cobblemon.mod.common.pokemon.stat.CobblemonStatProvider
+import com.cobblemon.mod.common.sherds.CobblemonSherds
+import com.cobblemon.mod.common.starter.CobblemonStarterHandler
+import com.cobblemon.mod.common.trade.TradeManager
+import com.cobblemon.mod.common.util.*
+import com.cobblemon.mod.common.world.feature.CobblemonPlacedFeatures
+import com.cobblemon.mod.common.world.feature.ore.CobblemonOrePlacedFeatures
+import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules
+import com.mongodb.ConnectionString
+import com.mongodb.MongoClientSettings
+import com.mongodb.client.MongoClient
+import com.mongodb.client.MongoClients
+import net.minecraft.client.MinecraftClient
+import net.minecraft.command.argument.serialize.ConstantArgumentSerializer
+import net.minecraft.entity.data.TrackedDataHandlerRegistry
+import net.minecraft.item.Items
+import net.minecraft.item.NameTagItem
+import net.minecraft.registry.RegistryKey
+import net.minecraft.util.WorldSavePath
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.World
+import org.apache.logging.log4j.LogManager
+import org.apache.logging.log4j.Logger
+import java.io.File
+import java.io.FileReader
+import java.io.FileWriter
+import java.io.PrintWriter
+import java.util.*
+import kotlin.properties.Delegates
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.jvm.isAccessible
+import kotlin.reflect.jvm.javaField
+import kotlin.math.roundToInt
+
+object Cobblemon {
+    const val MODID = CobblemonBuildDetails.MOD_ID
+    const val VERSION = CobblemonBuildDetails.VERSION
+    const val CONFIG_PATH = "config/$MODID/main.json"
+    val LOGGER: Logger = LogManager.getLogger()
+
+    lateinit var implementation: CobblemonImplementation
+    @Deprecated("This field is now a config value", ReplaceWith("Cobblemon.config.captureCalculator"))
+    var captureCalculator: CaptureCalculator
+        get() = this.config.captureCalculator
+        set(value) {
+            this.config.captureCalculator = value
+        }
+    var experienceCalculator: ExperienceCalculator = StandardExperienceCalculator
+    var evYieldCalculator: EvCalculator = Generation8EvCalculator
+    var starterHandler: StarterHandler = CobblemonStarterHandler()
+    var isDedicatedServer = false
+    val showdownThread = ShowdownThread()
+    lateinit var config: CobblemonConfig
+    var prospector: SpawningProspector = CobblemonSpawningProspector
+    var areaContextResolver: AreaContextResolver = object : AreaContextResolver {}
+    val bestSpawner = BestSpawner
+    val battleRegistry = BattleRegistry
+    var storage = PokemonStoreManager()
+    var molangData = NbtMoLangDataStoreFactory
+    lateinit var playerData: PlayerDataStoreManager
+    lateinit var starterConfig: StarterConfig
+    val dataProvider: DataProvider = CobblemonDataProvider
+    var permissionValidator: PermissionValidator by Delegates.observable(LaxPermissionValidator().also { it.initialize() }) { _, _, newValue -> newValue.initialize() }
+    var statProvider: StatProvider = CobblemonStatProvider
+    var seasonResolver: SeasonResolver = TagSeasonResolver
+
+    fun preInitialize(implementation: CobblemonImplementation) {
+        this.implementation = implementation
+
+        this.LOGGER.info("Launching Cobblemon ${CobblemonBuildDetails.VERSION}${if(CobblemonBuildDetails.SNAPSHOT) "-SNAPSHOT" else ""} ")
+        if(CobblemonBuildDetails.SNAPSHOT) {
+            this.LOGGER.info("  - Git Commit: ${smallCommitHash()} (https://gitlab.com/cable-mc/cobblemon/-/commit/${CobblemonBuildDetails.GIT_COMMIT})")
+            this.LOGGER.info("  - Branch: ${CobblemonBuildDetails.BRANCH}")
+        }
+
+        implementation.registerPermissionValidator()
+        implementation.registerSoundEvents()
+        implementation.registerBlocks()
+        implementation.registerItems()
+        implementation.registerEntityTypes()
+        implementation.registerEntityAttributes()
+        implementation.registerBlockEntityTypes()
+        implementation.registerWorldGenFeatures()
+        implementation.registerParticles()
+
+        DropEntry.register("command", CommandDropEntry::class.java)
+        DropEntry.register("item", ItemDropEntry::class.java, isDefault = true)
+
+        ExperienceGroups.registerDefaults()
+        CaptureCalculators.registerDefaults()
+
+        this.loadConfig()
+//        CobblemonBlockPredicates.touch()
+        CobblemonOrePlacedFeatures.register()
+        CobblemonPlacedFeatures.register()
+        this.registerArgumentTypes()
+
+        CobblemonCriteria // Init the fields and register the criteria
+        CobblemonGameRules // Init fields and register
+
+        ShoulderEffectRegistry.register()
+
+        DATA_SYNCHRONIZED.subscribe {
+            storage.onPlayerDataSync(it)
+            playerData.get(it).sendToPlayer(it)
+            starterHandler.handleJoin(it)
+            ServerSettingsPacket(this.config.preventCompletePartyDeposit, this.config.displayEntityLevelLabel).sendToPlayer(it)
+        }
+        PlatformEvents.SERVER_PLAYER_LOGOUT.subscribe {
+            PCLinkManager.removeLink(it.player.uuid)
+            BattleRegistry.getBattleByParticipatingPlayer(it.player)?.stop()
+            storage.onPlayerDisconnect(it.player)
+            playerData.onPlayerDisconnect(it.player)
+            TradeManager.onLogoff(it.player)
+        }
+        PlatformEvents.PLAYER_DEATH.subscribe {
+            PCLinkManager.removeLink(it.player.uuid)
+            battleRegistry.getBattleByParticipatingPlayer(it.player)?.stop()
+        }
+
+        PlatformEvents.RIGHT_CLICK_ENTITY.subscribe { event ->
+            if (event.player.getStackInHand(event.hand).item is NameTagItem && event.entity.type.isIn(CobblemonEntityTypeTags.CANNOT_HAVE_NAME_TAG)) {
+                event.cancel()
+            }
+        }
+        PlatformEvents.RIGHT_CLICK_BLOCK.subscribe { event ->
+            val player = event.player
+            val block = player.world.getBlockState(event.pos).block
+            player.party().forEach { pokemon ->
+                pokemon.evolutions
+                    .filterIsInstance<BlockClickEvolution>()
+                    .forEach { evolution ->
+                        evolution.attemptEvolution(pokemon, BlockClickEvolution.BlockInteractionContext(block, player.world))
+                    }
+            }
+        }
+
+        // Register the grow_tumblestone advancement
+        PlatformEvents.RIGHT_CLICK_BLOCK.subscribe { AdvancementHandler.onTumbleStonePlaced(it) }
+
+        PlatformEvents.CHANGE_DIMENSION.subscribe {
+            it.player.party().forEach { pokemon -> pokemon.entity?.recallWithAnimation() }
+        }
+
+        TrackedDataHandlerRegistry.register(Vec3DataSerializer)
+        TrackedDataHandlerRegistry.register(StringSetDataSerializer)
+        TrackedDataHandlerRegistry.register(PoseTypeDataSerializer)
+        TrackedDataHandlerRegistry.register(IdentifierDataSerializer)
+        TrackedDataHandlerRegistry.register(IdentifierDataSerializer)
+        TrackedDataHandlerRegistry.register(UUIDSetDataSerializer)
+
+        // Lowest priority because this applies after luxury ball bonus as of gen 4
+        CobblemonEvents.FRIENDSHIP_UPDATED.subscribe(Priority.LOWEST) { event ->
+            var increment = (event.newFriendship - event.pokemon.friendship).toFloat()
+            // Our Luxury ball spec is diff from official, but we will still assume these stack
+            if (event.pokemon.heldItemNoCopy().isIn(CobblemonItemTags.IS_FRIENDSHIP_BOOSTER)) {
+                increment += increment * 0.5F
+            }
+            event.newFriendship = event.pokemon.friendship + increment.roundToInt()
+        }
+
+        HeldItemProvider.register(CobblemonHeldItemManager, Priority.LOWEST)
+    }
+
+    fun initialize() {
+        showdownThread.launch()
+
+        // Start up the data provider.
+        CobblemonDataProvider.registerDefaults()
+
+        SHINY_ASPECT.register()
+        GENDER_ASPECT.register()
+
+        SpeciesFeatures.types["choice"] = ChoiceSpeciesFeatureProvider::class.java
+        SpeciesFeatures.types["flag"] = FlagSpeciesFeatureProvider::class.java
+        SpeciesFeatures.types["integer"] = IntSpeciesFeatureProvider::class.java
+
+        SpeciesFeatures.register(
+            DataKeys.CAN_BE_MILKED,
+            FlagSpeciesFeatureProvider(keys = listOf(DataKeys.CAN_BE_MILKED), default = true))
+        SpeciesFeatures.register(
+            DataKeys.HAS_BEEN_SHEARED,
+            FlagSpeciesFeatureProvider(keys = listOf(DataKeys.HAS_BEEN_SHEARED), default = false))
+
+        CustomPokemonProperty.register(UncatchableProperty)
+        CustomPokemonProperty.register(PokemonFlagProperty)
+        CustomPokemonProperty.register(HiddenAbilityPropertyType)
+        CustomPokemonProperty.register(AspectPropertyType)
+        CustomPokemonProperty.register(UnaspectPropertyType)
+
+        FlowHandler.setup()
+
+        ifDedicatedServer {
+            isDedicatedServer = true
+        }
+
+        PlatformEvents.SERVER_TICK_POST.subscribe {
+            ServerTaskTracker.update(1/20F)
+            ServerRealTimeTaskTracker.update()
+        }
+        PlatformEvents.SERVER_TICK_PRE.subscribe {
+            ServerRealTimeTaskTracker.update()
+        }
+        PlatformEvents.SERVER_STARTING.subscribe { event ->
+            val server = event.server
+            playerData = PlayerDataStoreManager().also { it.setup(server) }
+
+            val mongoClient: MongoClient?
+
+            val pokemonStoreRoot = server.getSavePath(WorldSavePath.ROOT).resolve("pokemon").toFile()
+            val storeAdapter = when (config.storageFormat) {
+                "nbt", "json" -> {
+                    val jsonFactory = JsonPlayerDataStoreFactory()
+                    jsonFactory.setup(server)
+                    playerData.setFactory(jsonFactory)
+
+                    if (config.storageFormat == "nbt") {
+                        NBTStoreAdapter(pokemonStoreRoot.absolutePath, useNestedFolders = true, folderPerClass = true)
+                    } else {
+                        JSONStoreAdapter(
+                            pokemonStoreRoot.absolutePath,
+                            useNestedFolders = true,
+                            folderPerClass = true
+                        )
+                    }
+                }
+
+                "mongodb" -> {
+                    try {
+                        Class.forName("com.mongodb.client.MongoClient")
+
+                        val mongoClientSettings = MongoClientSettings.builder()
+                            .applyConnectionString(ConnectionString(config.mongoDBConnectionString))
+                            .build()
+                        mongoClient = MongoClients.create(mongoClientSettings)
+                        val mongoFactory = MongoPlayerDataStoreFactory(mongoClient, config.mongoDBDatabaseName)
+                        playerData.setFactory(mongoFactory)
+                        MongoDBStoreAdapter(mongoClient, config.mongoDBDatabaseName)
+                    } catch (e: ClassNotFoundException) {
+                        LOGGER.error("MongoDB driver not found.")
+                        throw e
+                    }
+                }
+
+                else -> throw IllegalArgumentException("Unsupported storageFormat: ${config.storageFormat}")
+            }
+                .with(ReforgedConversion(server.getSavePath(WorldSavePath.ROOT))) as FileStoreAdapter<*>
+
+            storage.registerFactory(
+                priority = Priority.LOWEST,
+                factory = FileBackedPokemonStoreFactory(
+                    adapter = storeAdapter,
+                    createIfMissing = true,
+                    pcConstructor = { uuid -> PCStore(uuid).also { it.resize(config.defaultBoxCount) } }
+                )
+            )
+        }
+
+        PlatformEvents.SERVER_STOPPED.subscribe {
+            storage.unregisterAll()
+            playerData.saveAll()
+        }
+        PlatformEvents.SERVER_STARTED.subscribe {
+            bestSpawner.onServerStarted()
+            battleRegistry.onServerStarted()
+        }
+        PlatformEvents.SERVER_TICK_POST.subscribe { ServerTickHandler.onTick(it.server) }
+        POKEMON_CAPTURED.subscribe { AdvancementHandler.onCapture(it) }
+//        EGG_HATCH.subscribe { AdvancementHandler.onHatch(it) }
+        BATTLE_VICTORY.subscribe { AdvancementHandler.onWinBattle(it) }
+        EVOLUTION_COMPLETE.subscribe(Priority.LOWEST) { event ->
+            AdvancementHandler.onEvolve(event)
+            val pokemon = event.pokemon
+            val ninjaskIdentifier = cobblemonResource("ninjask")
+            // Ensure the config option is enabled and that the result was a ninjask and that shedinja exists
+            if (this.config.ninjaskCreatesShedinja && pokemon.species.resourceIdentifier == ninjaskIdentifier && PokemonSpecies.getByIdentifier(Pokemon.SHEDINJA) != null) {
+                val player = pokemon.getOwnerPlayer() ?: return@subscribe
+                if (player.isCreative || player.inventory.containsAny { it.item is PokeBallItem }) {
+                    var pokeball = Items.AIR
+                    player.inventory.combinedInventory.forEach {
+                        it.forEach {
+                            itemStack -> if (itemStack.item is PokeBallItem && pokeball == Items.AIR) {
+                                pokeball = itemStack.item as PokeBallItem
+                            }
+                        }
+                    }
+                    if (!player.isCreative) {
+                        player.inventory.removeAmountIf(1) { it.item is PokeBallItem }
+                    }
+                    if (pokeball == Items.AIR) {
+                        pokeball = CobblemonItems.POKE_BALL
+                    }
+                    val properties = event.evolution.result.copy()
+                    properties.species = Pokemon.SHEDINJA.toString()
+                    val product = pokemon.clone()
+                    product.removeHeldItem()
+                    properties.apply(product)
+                    product.caughtBall = (pokeball as PokeBallItem).pokeBall
+                    pokemon.storeCoordinates.get()?.store?.add(product)
+                    CobblemonCriteria.EVOLVE_POKEMON.trigger(player, EvolvePokemonContext(event.pokemon.preEvolution!!.species.resourceIdentifier, product.species.resourceIdentifier, playerData.get(player).advancementData.totalEvolvedCount))
+                }
+            }
+        }
+        LEVEL_UP_EVENT.subscribe { AdvancementHandler.onLevelUp(it) }
+        TRADE_COMPLETED.subscribe { AdvancementHandler.onTradeCompleted(it) }
+
+        BagItems.observable.subscribe {
+            LOGGER.info("Starting dummy Showdown battle to force it to pre-load data.")
+            battleRegistry.startBattle(
+                BattleFormat.GEN_9_SINGLES,
+                BattleSide(PokemonBattleActor(UUID.randomUUID(), BattlePokemon(Pokemon().initialize()), -1F)),
+                BattleSide(PokemonBattleActor(UUID.randomUUID(), BattlePokemon(Pokemon().initialize()), -1F)),
+                true
+            ).ifSuccessful { it.mute = true }
+        }
+
+        CobblemonSherds.registerSherds()
+    }
+
+    fun getLevel(dimension: RegistryKey<World>): World? {
+        return if (isDedicatedServer) {
+            server()?.getWorld(dimension)
+        } else {
+            val mc = MinecraftClient.getInstance()
+            return mc.server?.getWorld(dimension) ?: mc.world
+        }
+    }
+
+    fun loadConfig() {
+        val configFile = File(CONFIG_PATH)
+        configFile.parentFile.mkdirs()
+
+        // Check config existence and load if it exists, otherwise create default.
+        if (configFile.exists()) {
+            try {
+                val fileReader = FileReader(configFile)
+                this.config = CobblemonConfig.GSON.fromJson(fileReader, CobblemonConfig::class.java)
+                fileReader.close()
+            } catch (exception: Exception) {
+                LOGGER.error("Failed to load the config! Using default config until the following has been addressed:")
+                this.config = CobblemonConfig()
+                exception.printStackTrace()
+            }
+
+            val defaultConfig = CobblemonConfig()
+
+            CobblemonConfig::class.memberProperties.forEach {
+                val field = it.javaField!!
+                it.isAccessible = true
+                field.annotations.forEach {
+                    when (it) {
+                        is LastChangedVersion -> {
+                            val defaultChangedVersion = it.version
+                            val lastSavedVersion = config.lastSavedVersion
+                            if (defaultChangedVersion.isLaterVersion(lastSavedVersion)) {
+                                field.set(config, field.get(defaultConfig))
+                            }
+                        }
+                        is IntConstraint -> {
+                            var value = field.get(config)
+                            if (value is Int) {
+                                value = value.coerceIn(it.min, it.max)
+                                field.set(config, value)
+                            }
+                        }
+                    }
+                }
+            }
+        } else {
+            this.config = CobblemonConfig()
+        }
+
+        config.lastSavedVersion = VERSION
+        this.saveConfig()
+
+        bestSpawner.loadConfig()
+        PokemonSpecies.observable.subscribe { starterConfig = this.loadStarterConfig() }
+    }
+
+    fun loadStarterConfig(): StarterConfig {
+        if (config.exportStarterConfig) {
+            val file = File("config/cobblemon/starters.json")
+            file.parentFile.mkdirs()
+            if (!file.exists()) {
+                val config = StarterConfig()
+                val pw = PrintWriter(file)
+                StarterConfig.GSON.toJson(config, pw)
+                pw.close()
+                return config
+            }
+            val reader = FileReader(file)
+            val config = StarterConfig.GSON.fromJson(reader, StarterConfig::class.java)
+            reader.close()
+            return config
+        } else {
+            return StarterConfig()
+        }
+    }
+
+    fun saveConfig() {
+        try {
+            val configFile = File(CONFIG_PATH)
+            val fileWriter = FileWriter(configFile)
+            // Put the config to json then flush the writer to commence writing.
+            CobblemonConfig.GSON.toJson(this.config, fileWriter)
+            fileWriter.flush()
+            fileWriter.close()
+        } catch (exception: Exception) {
+            LOGGER.error("Failed to save the config! Please consult the following stack trace:")
+            exception.printStackTrace()
+        }
+    }
+
+    private fun registerArgumentTypes() {
+        this.implementation.registerCommandArgument(cobblemonResource("pokemon"), PokemonArgumentType::class, ConstantArgumentSerializer.of(PokemonArgumentType::pokemon))
+        this.implementation.registerCommandArgument(cobblemonResource("pokemon_properties"), PokemonPropertiesArgumentType::class, ConstantArgumentSerializer.of(PokemonPropertiesArgumentType::properties))
+        this.implementation.registerCommandArgument(cobblemonResource("spawn_bucket"), SpawnBucketArgumentType::class, ConstantArgumentSerializer.of(SpawnBucketArgumentType::spawnBucket))
+        this.implementation.registerCommandArgument(cobblemonResource("move"), MoveArgumentType::class, ConstantArgumentSerializer.of(MoveArgumentType::move))
+        this.implementation.registerCommandArgument(cobblemonResource("party_slot"), PartySlotArgumentType::class, ConstantArgumentSerializer.of(PartySlotArgumentType::partySlot))
+        this.implementation.registerCommandArgument(cobblemonResource("pokemon_store"), PokemonStoreArgumentType::class, ConstantArgumentSerializer.of(PokemonStoreArgumentType::pokemonStore))
+        this.implementation.registerCommandArgument(cobblemonResource("dialogue"), DialogueArgumentType::class, ConstantArgumentSerializer.of(DialogueArgumentType::dialogue))
+    }
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonActivities.kt

@@ -0,0 +1,22 @@
+/*
+ * 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.entity.ai.brain.Activity
+
+object CobblemonActivities {
+    val activities = mutableListOf<Activity>()
+    val BATTLING_ACTIVITY = Activity("pokemon_battling")
+    val NPC_BATTLING = Activity("npc_battling")
+
+    fun register(activity: Activity): Activity {
+        activities.add(activity)
+        return activity
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonBlockEntities.kt

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.block.entity.BerryBlockEntity
+import com.cobblemon.mod.common.block.entity.HealingMachineBlockEntity
+import com.cobblemon.mod.common.block.entity.PCBlockEntity
+import com.cobblemon.mod.common.block.entity.PokemonPastureBlockEntity
+import com.cobblemon.mod.common.block.entity.FossilAnalyzerBlockEntity
+import com.cobblemon.mod.common.block.entity.FossilMultiblockEntity
+import com.cobblemon.mod.common.block.entity.RestorationTankBlockEntity
+import com.cobblemon.mod.common.block.multiblock.FossilMultiblockBuilder
+import com.cobblemon.mod.common.block.entity.*
+import com.cobblemon.mod.common.block.entity.DisplayCaseBlockEntity
+import com.cobblemon.mod.common.platform.PlatformRegistry
+import net.minecraft.block.entity.BlockEntityType
+import net.minecraft.registry.Registries
+import net.minecraft.registry.Registry
+import net.minecraft.registry.RegistryKey
+import net.minecraft.registry.RegistryKeys
+
+object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, RegistryKey<Registry<BlockEntityType<*>>>, BlockEntityType<*>>() {
+
+    override val registry: Registry<BlockEntityType<*>> = Registries.BLOCK_ENTITY_TYPE
+    override val registryKey: RegistryKey<Registry<BlockEntityType<*>>> = RegistryKeys.BLOCK_ENTITY_TYPE
+
+    @JvmField
+    val HEALING_MACHINE: BlockEntityType<HealingMachineBlockEntity> = this.create("healing_machine", BlockEntityType.Builder.create(::HealingMachineBlockEntity, CobblemonBlocks.HEALING_MACHINE).build(null))
+
+    @JvmField
+    val PC: BlockEntityType<PCBlockEntity> = this.create("pc", BlockEntityType.Builder.create(::PCBlockEntity, CobblemonBlocks.PC).build(null))
+
+    @JvmField
+    val BERRY = this.create("berry", BlockEntityType.Builder.create(::BerryBlockEntity, *CobblemonBlocks.berries().values.toTypedArray()).build(null))
+
+    @JvmField
+    val PASTURE: BlockEntityType<PokemonPastureBlockEntity> = this.create("pasture", BlockEntityType.Builder.create(::PokemonPastureBlockEntity, CobblemonBlocks.PASTURE).build(null))
+    @JvmField
+    val SIGN: BlockEntityType<CobblemonSignBlockEntity> = this.create("sign", BlockEntityType.Builder.create(::CobblemonSignBlockEntity, CobblemonBlocks.APRICORN_SIGN, CobblemonBlocks.APRICORN_WALL_SIGN).build(null))
+    @JvmField
+    val HANGING_SIGN: BlockEntityType<CobblemonHangingSignBlockEntity> = this.create("hanging_sign", BlockEntityType.Builder.create(::CobblemonHangingSignBlockEntity, CobblemonBlocks.APRICORN_HANGING_SIGN, CobblemonBlocks.APRICORN_WALL_HANGING_SIGN).build(null))
+
+    @JvmField
+    val GILDED_CHEST: BlockEntityType<GildedChestBlockEntity> = this.create("chest", BlockEntityType.Builder.create(::GildedChestBlockEntity,
+        CobblemonBlocks.GILDED_CHEST,
+        CobblemonBlocks.BLUE_GILDED_CHEST,
+        CobblemonBlocks.YELLOW_GILDED_CHEST,
+        CobblemonBlocks.PINK_GILDED_CHEST,
+        CobblemonBlocks.BLACK_GILDED_CHEST,
+        CobblemonBlocks.WHITE_GILDED_CHEST,
+        CobblemonBlocks.GREEN_GILDED_CHEST,
+        CobblemonBlocks.GIMMIGHOUL_CHEST
+    ).build(null))
+
+    @JvmField
+    val FOSSIL_MULTIBLOCK: BlockEntityType<FossilMultiblockEntity> = this.create("fossil_multiblock",
+        BlockEntityType.Builder.create({ pos, state -> FossilMultiblockEntity(pos, state, FossilMultiblockBuilder(pos)) },
+            CobblemonBlocks.MONITOR
+        ).build(null)
+    )
+
+    @JvmField
+    val RESTORATION_TANK: BlockEntityType<RestorationTankBlockEntity> = this.create("restoration_tank",
+        BlockEntityType.Builder.create({ pos, state -> RestorationTankBlockEntity(pos, state, FossilMultiblockBuilder(pos)) },
+            CobblemonBlocks.RESTORATION_TANK
+        ).build(null)
+    )
+
+    @JvmField
+    val FOSSIL_ANALYZER: BlockEntityType<FossilAnalyzerBlockEntity> = this.create("fossil_analyzer",
+        BlockEntityType.Builder.create({ pos, state -> FossilAnalyzerBlockEntity(pos, state, FossilMultiblockBuilder(pos)) },
+            CobblemonBlocks.FOSSIL_ANALYZER
+        ).build(null)
+    )
+
+    @JvmField
+    val DISPLAY_CASE: BlockEntityType<DisplayCaseBlockEntity> = this.create("display_case",
+        BlockEntityType.Builder.create(::DisplayCaseBlockEntity, CobblemonBlocks.DISPLAY_CASE).build(null)
+    )
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonBlocks.kt

@@ -0,0 +1,595 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.api.apricorn.Apricorn
+import com.cobblemon.mod.common.block.*
+import com.cobblemon.mod.common.block.MintBlock.MintType
+import com.cobblemon.mod.common.block.FossilAnalyzerBlock
+import com.cobblemon.mod.common.block.MonitorBlock
+import com.cobblemon.mod.common.block.RestorationTankBlock
+import com.cobblemon.mod.common.mixin.invoker.DoorBlockInvoker
+import com.cobblemon.mod.common.mixin.invoker.PressurePlateBlockInvoker
+import com.cobblemon.mod.common.mixin.invoker.StairsBlockInvoker
+import com.cobblemon.mod.common.mixin.invoker.TrapdoorBlockInvoker
+import com.cobblemon.mod.common.mixin.invoker.*
+import com.cobblemon.mod.common.platform.PlatformRegistry
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.block.BerryBlock
+import com.cobblemon.mod.common.block.chest.GildedChestBlock
+import com.cobblemon.mod.common.block.sign.CobblemonHangingSignBlock
+import com.cobblemon.mod.common.block.sign.CobblemonSignBlock
+import com.cobblemon.mod.common.block.sign.CobblemonWallHangingSignBlock
+import com.cobblemon.mod.common.block.sign.CobblemonWallSignBlock
+import net.minecraft.block.*
+import net.minecraft.block.enums.Instrument
+import net.minecraft.block.piston.PistonBehavior
+import net.minecraft.entity.effect.StatusEffects
+import net.minecraft.registry.Registries
+import net.minecraft.registry.Registry
+import net.minecraft.registry.RegistryKey
+import net.minecraft.registry.RegistryKeys
+import net.minecraft.sound.BlockSoundGroup
+import net.minecraft.util.Identifier
+import net.minecraft.util.math.intprovider.UniformIntProvider
+
+@Suppress("SameParameterValue", "HasPlatformType", "MemberVisibilityCanBePrivate", "unused")
+object CobblemonBlocks : PlatformRegistry<Registry<Block>, RegistryKey<Registry<Block>>, Block>() {
+
+
+
+    override val registry: Registry<Block> = Registries.BLOCK
+    override val registryKey: RegistryKey<Registry<Block>> = RegistryKeys.BLOCK
+
+    val APRICORN_BLOCK_SET_TYPE = BlockSetType("apricorn")
+    val APRICORN_WOOD_TYPE = WoodType.register(WoodType("apricorn", APRICORN_BLOCK_SET_TYPE))
+
+    // Evolution Ores
+    @JvmField
+    val DAWN_STONE_ORE = evolutionStoneOre("dawn_stone_ore")
+    @JvmField
+    val DUSK_STONE_ORE = evolutionStoneOre("dusk_stone_ore")
+    @JvmField
+    val FIRE_STONE_ORE = evolutionStoneOre("fire_stone_ore")
+    @JvmField
+    val NETHER_FIRE_STONE_ORE = evolutionStoneOre("nether_fire_stone_ore")
+    @JvmField
+    val ICE_STONE_ORE = evolutionStoneOre("ice_stone_ore")
+    @JvmField
+    val LEAF_STONE_ORE = evolutionStoneOre("leaf_stone_ore")
+    @JvmField
+    val MOON_STONE_ORE = evolutionStoneOre("moon_stone_ore")
+    @JvmField
+    val DRIPSTONE_MOON_STONE_ORE = evolutionStoneOre("dripstone_moon_stone_ore")
+    @JvmField
+    val SHINY_STONE_ORE = evolutionStoneOre("shiny_stone_ore")
+    @JvmField
+    val SUN_STONE_ORE = evolutionStoneOre("sun_stone_ore")
+    @JvmField
+    val TERRACOTTA_SUN_STONE_ORE = evolutionStoneOre("terracotta_sun_stone_ore")
+    @JvmField
+    val THUNDER_STONE_ORE = evolutionStoneOre("thunder_stone_ore")
+    @JvmField
+    val WATER_STONE_ORE = evolutionStoneOre("water_stone_ore")
+
+    @JvmField
+    val DEEPSLATE_DAWN_STONE_ORE = this.deepslateEvolutionStoneOre("deepslate_dawn_stone_ore")
+    @JvmField
+    val DEEPSLATE_DUSK_STONE_ORE = this.deepslateEvolutionStoneOre("deepslate_dusk_stone_ore")
+    @JvmField
+    val DEEPSLATE_FIRE_STONE_ORE = this.deepslateEvolutionStoneOre("deepslate_fire_stone_ore")
+    @JvmField
+    val DEEPSLATE_ICE_STONE_ORE = this.deepslateEvolutionStoneOre("deepslate_ice_stone_ore")
+    @JvmField
+    val DEEPSLATE_LEAF_STONE_ORE = this.deepslateEvolutionStoneOre("deepslate_leaf_stone_ore")
+    @JvmField
+    val DEEPSLATE_MOON_STONE_ORE = this.deepslateEvolutionStoneOre("deepslate_moon_stone_ore")
+    @JvmField
+    val DEEPSLATE_SHINY_STONE_ORE = this.deepslateEvolutionStoneOre("deepslate_shiny_stone_ore")
+    @JvmField
+    val DEEPSLATE_SUN_STONE_ORE = this.deepslateEvolutionStoneOre("deepslate_sun_stone_ore")
+    @JvmField
+    val DEEPSLATE_THUNDER_STONE_ORE = this.deepslateEvolutionStoneOre("deepslate_thunder_stone_ore")
+    @JvmField
+    val DEEPSLATE_WATER_STONE_ORE = this.deepslateEvolutionStoneOre("deepslate_water_stone_ore")
+
+    // Apricorns
+    @JvmField
+    val APRICORN_LOG = log("apricorn_log", arg2 = MapColor.BROWN)
+    @JvmField
+    val STRIPPED_APRICORN_LOG = log("stripped_apricorn_log")
+    @JvmField
+    val APRICORN_WOOD = log("apricorn_wood")
+    @JvmField
+    val STRIPPED_APRICORN_WOOD = log("stripped_apricorn_wood")
+    @JvmField
+    val APRICORN_PLANKS = this.create("apricorn_planks", Block(AbstractBlock.Settings.create().mapColor(MapColor.DIRT_BROWN).instrument(Instrument.BASS).strength(2.0f, 3.0f).sounds(BlockSoundGroup.WOOD)))
+    @JvmField
+    val APRICORN_LEAVES = leaves("apricorn_leaves")
+    @JvmField
+    val APRICORN_FENCE = this.create("apricorn_fence", FenceBlock(AbstractBlock.Settings.create().mapColor(APRICORN_PLANKS.defaultMapColor).instrument(Instrument.BASS).strength(2.0f, 3.0f).sounds(BlockSoundGroup.WOOD)))
+    @JvmField
+    val APRICORN_FENCE_GATE = this.create("apricorn_fence_gate", FenceGateBlock(AbstractBlock.Settings.create().mapColor(APRICORN_PLANKS.defaultMapColor).instrument(Instrument.BASS).strength(2.0f, 3.0f).sounds(BlockSoundGroup.WOOD), APRICORN_WOOD_TYPE))
+    @JvmField // Note At the time of 1.20.0 we don't need our own BlockSetType for Apricorn wood
+    val APRICORN_BUTTON = this.create("apricorn_button", BlocksInvoker.createWoodenButtonBlock(BlockSetType.OAK))
+    @JvmField
+    val APRICORN_PRESSURE_PLATE = this.create("apricorn_pressure_plate", PressurePlateBlockInvoker.`cobblemon$create`(PressurePlateBlock.ActivationRule.EVERYTHING, AbstractBlock.Settings.create().mapColor(APRICORN_PLANKS.defaultMapColor).instrument(Instrument.BASS).noCollision().strength(0.5f).sounds(BlockSoundGroup.WOOD), APRICORN_BLOCK_SET_TYPE))
+    @JvmField
+    val APRICORN_SIGN = this.create("apricorn_sign", CobblemonSignBlock(AbstractBlock.Settings.copy(Blocks.OAK_SIGN), APRICORN_WOOD_TYPE))
+    @JvmField
+    val APRICORN_WALL_SIGN = this.create("apricorn_wall_sign", CobblemonWallSignBlock(AbstractBlock.Settings.copy(Blocks.OAK_WALL_SIGN), APRICORN_WOOD_TYPE))
+    @JvmField
+    val APRICORN_HANGING_SIGN = this.create("apricorn_hanging_sign", CobblemonHangingSignBlock(AbstractBlock.Settings.copy(Blocks.OAK_WALL_HANGING_SIGN), APRICORN_WOOD_TYPE))
+    @JvmField
+    val APRICORN_WALL_HANGING_SIGN = this.create("apricorn_wall_hanging_sign", CobblemonWallHangingSignBlock(AbstractBlock.Settings.copy(Blocks.OAK_HANGING_SIGN), APRICORN_WOOD_TYPE))
+    @JvmField
+    val APRICORN_SLAB = this.create("apricorn_slab", SlabBlock(AbstractBlock.Settings.create().mapColor(MapColor.OAK_TAN).instrument(Instrument.BASS).strength(2.0f, 3.0f).sounds(BlockSoundGroup.WOOD)))
+    @JvmField
+    val APRICORN_STAIRS = this.create("apricorn_stairs", StairsBlockInvoker.`cobblemon$create`(APRICORN_PLANKS.defaultState, AbstractBlock.Settings.copy(APRICORN_PLANKS)))
+    @JvmField
+    val APRICORN_DOOR = this.create("apricorn_door", DoorBlockInvoker.`cobblemon$create`(AbstractBlock.Settings.create().mapColor(APRICORN_PLANKS.defaultMapColor).instrument(Instrument.BASS).strength(3.0F).sounds(BlockSoundGroup.WOOD).nonOpaque(), APRICORN_BLOCK_SET_TYPE))
+    @JvmField
+    val APRICORN_TRAPDOOR = this.create("apricorn_trapdoor", TrapdoorBlockInvoker.`cobblemon$create`(AbstractBlock.Settings.create().mapColor(MapColor.OAK_TAN).instrument(Instrument.BASS).strength(3.0F).sounds(BlockSoundGroup.WOOD).nonOpaque().allowsSpawning { _, _, _, _ -> false }, APRICORN_BLOCK_SET_TYPE))
+
+    private val PLANT_PROPERTIES = AbstractBlock.Settings.create().mapColor(MapColor.DARK_GREEN).noCollision().ticksRandomly().breakInstantly().sounds(BlockSoundGroup.GRASS).pistonBehavior(PistonBehavior.DESTROY)
+    @JvmField
+    val BLACK_APRICORN_SAPLING = this.create("black_apricorn_sapling", ApricornSaplingBlock(PLANT_PROPERTIES, Apricorn.BLACK))
+    @JvmField
+    val BLUE_APRICORN_SAPLING = this.create("blue_apricorn_sapling", ApricornSaplingBlock(PLANT_PROPERTIES, Apricorn.BLUE))
+    @JvmField
+    val GREEN_APRICORN_SAPLING = this.create("green_apricorn_sapling", ApricornSaplingBlock(PLANT_PROPERTIES, Apricorn.GREEN))
+    @JvmField
+    val PINK_APRICORN_SAPLING = this.create("pink_apricorn_sapling", ApricornSaplingBlock(PLANT_PROPERTIES, Apricorn.PINK))
+    @JvmField
+    val RED_APRICORN_SAPLING = this.create("red_apricorn_sapling", ApricornSaplingBlock(PLANT_PROPERTIES, Apricorn.RED))
+    @JvmField
+    val WHITE_APRICORN_SAPLING = this.create("white_apricorn_sapling", ApricornSaplingBlock(PLANT_PROPERTIES, Apricorn.WHITE))
+    @JvmField
+    val YELLOW_APRICORN_SAPLING = this.create("yellow_apricorn_sapling", ApricornSaplingBlock(PLANT_PROPERTIES, Apricorn.YELLOW))
+
+    @JvmField
+    val MEDICINAL_LEEK = this.create("medicinal_leek", MedicinalLeekBlock(AbstractBlock.Settings.create().pistonBehavior(PistonBehavior.DESTROY).burnable().mapColor(MapColor.DULL_RED).noCollision().ticksRandomly().breakInstantly().sounds(CobblemonSounds.MEDICINAL_LEEK_SOUNDS)))
+    @JvmField
+    val ENERGY_ROOT = this.create("energy_root", EnergyRootBlock(AbstractBlock.Settings.create().pistonBehavior(PistonBehavior.DESTROY).burnable().mapColor(MapColor.DIRT_BROWN).noCollision().ticksRandomly().breakInstantly().sounds(CobblemonSounds.ENERGY_ROOT_SOUNDS)))
+    @JvmField
+    val BIG_ROOT = this.create("big_root", BigRootBlock(AbstractBlock.Settings.create().pistonBehavior(PistonBehavior.DESTROY).burnable().mapColor(MapColor.DARK_GREEN).noCollision().ticksRandomly().breakInstantly().sounds(CobblemonSounds.BIG_ROOT_SOUNDS)))
+    @JvmField
+    val REVIVAL_HERB = this.create("revival_herb", RevivalHerbBlock(AbstractBlock.Settings.create().pistonBehavior(PistonBehavior.DESTROY).mapColor(MapColor.DARK_GREEN).burnable().noCollision().breakInstantly().sounds(CobblemonSounds.REVIVAL_HERB_SOUNDS)))
+
+    @JvmField
+    val TUMBLESTONE_CLUSTER = tumblestoneBlock("tumblestone_cluster", GrowableStoneBlock.STAGE_3, 7, 3, null)
+    @JvmField
+    val LARGE_BUDDING_TUMBLESTONE = tumblestoneBlock("large_budding_tumblestone", GrowableStoneBlock.STAGE_2, 5, 3, TUMBLESTONE_CLUSTER)
+    @JvmField
+    val MEDIUM_BUDDING_TUMBLESTONE = tumblestoneBlock("medium_budding_tumblestone", GrowableStoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_TUMBLESTONE)
+    @JvmField
+    val SMALL_BUDDING_TUMBLESTONE = tumblestoneBlock("small_budding_tumblestone", GrowableStoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_TUMBLESTONE)
+
+    @JvmField
+    val SKY_TUMBLESTONE_CLUSTER = tumblestoneBlock("sky_tumblestone_cluster", GrowableStoneBlock.STAGE_3, 7, 3, null)
+    @JvmField
+    val LARGE_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("large_budding_sky_tumblestone", GrowableStoneBlock.STAGE_2, 5, 3, SKY_TUMBLESTONE_CLUSTER)
+    @JvmField
+    val MEDIUM_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("medium_budding_sky_tumblestone", GrowableStoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_SKY_TUMBLESTONE)
+    @JvmField
+    val SMALL_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("small_budding_sky_tumblestone", GrowableStoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_SKY_TUMBLESTONE)
+
+    @JvmField
+    val BLACK_TUMBLESTONE_CLUSTER = tumblestoneBlock("black_tumblestone_cluster", GrowableStoneBlock.STAGE_3, 7, 3, null)
+    @JvmField
+    val LARGE_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("large_budding_black_tumblestone", GrowableStoneBlock.STAGE_2, 5, 3, BLACK_TUMBLESTONE_CLUSTER)
+    @JvmField
+    val MEDIUM_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("medium_budding_black_tumblestone", GrowableStoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_BLACK_TUMBLESTONE)
+    @JvmField
+    val SMALL_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("small_budding_black_tumblestone", GrowableStoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_BLACK_TUMBLESTONE)
+
+    @JvmField
+    val TUMBLESTONE_BLOCK = this.create("tumblestone_block", Block(AbstractBlock.Settings.create()
+        .mapColor(MapColor.TERRACOTTA_ORANGE)
+        .strength(1.0F)
+        .sounds(CobblemonSounds.TUMBLESTONE_BLOCK_SOUNDS)
+        .requiresTool()
+        .instrument(Instrument.BASEDRUM)
+    ))
+    @JvmField
+    val SKY_TUMBLESTONE_BLOCK = this.create("sky_tumblestone_block", Block(AbstractBlock.Settings.create()
+        .mapColor(MapColor.LIGHT_BLUE)
+        .strength(1.0F)
+        .sounds(CobblemonSounds.TUMBLESTONE_BLOCK_SOUNDS)
+        .requiresTool()
+        .instrument(Instrument.BASEDRUM)
+    ))
+    @JvmField
+    val BLACK_TUMBLESTONE_BLOCK = this.create("black_tumblestone_block", Block(AbstractBlock.Settings.create()
+        .mapColor(MapColor.TERRACOTTA_BLACK)
+        .strength(1.0F)
+        .sounds(CobblemonSounds.TUMBLESTONE_BLOCK_SOUNDS)
+        .requiresTool()
+        .instrument(Instrument.BASEDRUM)
+    ))
+
+    @JvmField
+    val BLACK_APRICORN = apricornBlock("black_apricorn", Apricorn.BLACK)
+    @JvmField
+    val BLUE_APRICORN = apricornBlock("blue_apricorn", Apricorn.BLUE)
+    @JvmField
+    val GREEN_APRICORN = apricornBlock("green_apricorn", Apricorn.GREEN)
+    @JvmField
+    val PINK_APRICORN = apricornBlock("pink_apricorn", Apricorn.PINK)
+    @JvmField
+    val RED_APRICORN = apricornBlock("red_apricorn", Apricorn.RED)
+    @JvmField
+    val WHITE_APRICORN = apricornBlock("white_apricorn", Apricorn.WHITE)
+    @JvmField
+    val YELLOW_APRICORN = apricornBlock("yellow_apricorn", Apricorn.YELLOW)
+
+    @JvmField
+    val RELIC_COIN_POUCH = create(
+        "relic_coin_pouch",
+        CoinPouchBlock(
+            AbstractBlock.Settings.create()
+                .sounds(CobblemonSounds.RELIC_COIN_POUCH_SOUNDS)
+                .pistonBehavior(PistonBehavior.DESTROY)
+                .strength(0.4f)
+                .nonOpaque(), true
+        )
+    )
+    @JvmField
+    val RELIC_COIN_SACK = create(
+        "relic_coin_sack",
+        CoinPouchBlock(
+            AbstractBlock.Settings.create()
+                .sounds(CobblemonSounds.RELIC_COIN_SACK_SOUNDS)
+                .pistonBehavior(PistonBehavior.DESTROY)
+                .strength(0.4f), false
+        ))
+
+    @JvmField
+    val GILDED_CHEST = create(
+        "gilded_chest",
+        GildedChestBlock(
+            AbstractBlock.Settings.copy(Blocks.CHEST).nonOpaque().sounds(CobblemonSounds.GILDED_CHEST_SOUNDS),
+            GildedChestBlock.Type.RED
+        )
+    )
+
+    @JvmField
+    val BLUE_GILDED_CHEST = create(
+        "blue_gilded_chest",
+        GildedChestBlock(
+            AbstractBlock.Settings.copy(Blocks.CHEST).nonOpaque().sounds(CobblemonSounds.GILDED_CHEST_SOUNDS),
+            GildedChestBlock.Type.BLUE
+        )
+    )
+
+    @JvmField
+    val BLACK_GILDED_CHEST = create(
+        "black_gilded_chest",
+        GildedChestBlock(
+            AbstractBlock.Settings.copy(Blocks.CHEST).nonOpaque().sounds(CobblemonSounds.GILDED_CHEST_SOUNDS),
+            GildedChestBlock.Type.BLACK
+        )
+    )
+
+    @JvmField
+    val YELLOW_GILDED_CHEST = create(
+        "yellow_gilded_chest",
+        GildedChestBlock(
+            AbstractBlock.Settings.copy(Blocks.CHEST).nonOpaque().sounds(CobblemonSounds.GILDED_CHEST_SOUNDS),
+            GildedChestBlock.Type.YELLOW
+        )
+    )
+
+    @JvmField
+    val WHITE_GILDED_CHEST = create(
+        "white_gilded_chest",
+        GildedChestBlock(
+            AbstractBlock.Settings.copy(Blocks.CHEST).nonOpaque().sounds(CobblemonSounds.GILDED_CHEST_SOUNDS),
+            GildedChestBlock.Type.WHITE
+        )
+    )
+
+    @JvmField
+    val GREEN_GILDED_CHEST = create(
+        "green_gilded_chest",
+        GildedChestBlock(
+            AbstractBlock.Settings.copy(Blocks.CHEST).nonOpaque().sounds(CobblemonSounds.GILDED_CHEST_SOUNDS),
+            GildedChestBlock.Type.GREEN
+        )
+    )
+
+    @JvmField
+    val PINK_GILDED_CHEST = create(
+        "pink_gilded_chest",
+        GildedChestBlock(
+            AbstractBlock.Settings.copy(Blocks.CHEST).nonOpaque().sounds(CobblemonSounds.GILDED_CHEST_SOUNDS),
+            GildedChestBlock.Type.PINK
+        )
+    )
+
+    @JvmField
+    val GIMMIGHOUL_CHEST = create(
+        "gimmighoul_chest",
+        GildedChestBlock(
+            AbstractBlock.Settings.copy(Blocks.CHEST).nonOpaque().sounds(CobblemonSounds.GILDED_CHEST_SOUNDS),
+            GildedChestBlock.Type.FAKE
+        )
+    )
+
+    @JvmField
+    val MONITOR = create(
+        "monitor",
+        MonitorBlock(
+            AbstractBlock.Settings.create()
+                .mapColor(MapColor.IRON_GRAY)
+                .sounds(BlockSoundGroup.METAL)
+                .pistonBehavior(PistonBehavior.BLOCK)
+                .requiresTool()
+                .strength(5.0F, 6.0F)
+                .luminance { if (it.get(MonitorBlock.SCREEN) != MonitorBlock.MonitorScreen.OFF) 15 else 0 }
+        )
+    )
+    @JvmField
+    val FOSSIL_ANALYZER = create(
+        "fossil_analyzer",
+        FossilAnalyzerBlock(
+            AbstractBlock.Settings.create()
+                .mapColor(MapColor.IRON_GRAY)
+                .sounds(BlockSoundGroup.METAL)
+                .pistonBehavior(PistonBehavior.BLOCK)
+                .requiresTool()
+                .strength(5.0F, 6.0F)
+                .nonOpaque()
+        )
+    )
+    @JvmField
+    val RESTORATION_TANK = create(
+        "restoration_tank",
+        RestorationTankBlock(
+            AbstractBlock.Settings.create()
+                .mapColor(MapColor.IRON_GRAY)
+                .sounds(BlockSoundGroup.GLASS)
+                .pistonBehavior(PistonBehavior.BLOCK)
+                .requiresTool()
+                .strength(5.0F, 6.0F)
+                .nonOpaque()
+        )
+    )
+    @JvmField
+    val HEALING_MACHINE = create(
+        "healing_machine",
+        HealingMachineBlock(
+            AbstractBlock.Settings.create()
+                .mapColor(MapColor.IRON_GRAY)
+                .sounds(BlockSoundGroup.METAL)
+                .pistonBehavior(PistonBehavior.BLOCK)
+                .strength(2f)
+                .nonOpaque()
+                .luminance { if (it.get(HealingMachineBlock.CHARGE_LEVEL) >= HealingMachineBlock.MAX_CHARGE_LEVEL) 7 else 2 }
+        )
+    )
+    @JvmField
+    val PC = create(
+        "pc",
+        PCBlock(
+            AbstractBlock.Settings.create()
+                .mapColor(MapColor.IRON_GRAY)
+                .sounds(BlockSoundGroup.METAL)
+                .pistonBehavior(PistonBehavior.BLOCK)
+                .strength(2F)
+                .nonOpaque()
+                .luminance { if ((it.get(PCBlock.ON) as Boolean) && (it.get(PCBlock.PART) == PCBlock.PCPart.TOP)) 10 else 0 }
+        )
+    )
+
+    @JvmField
+    val DISPLAY_CASE = create(
+        "display_case",
+        DisplayCaseBlock(
+            AbstractBlock.Settings.create()
+                .sounds(CobblemonSounds.DISPLAY_CASE_SOUNDS)
+                .nonOpaque()
+                .pistonBehavior(PistonBehavior.BLOCK)
+                .mapColor(MapColor.STONE_GRAY)
+                .strength(0.3f)
+        )
+    )
+
+    val RED_MINT = create("red_mint", MintBlock(MintType.RED, AbstractBlock.Settings.create().mapColor(MapColor.RED).noCollision().ticksRandomly().breakInstantly().sounds(CobblemonSounds.MINT_SOUNDS)))
+    @JvmField
+    val BLUE_MINT = create("blue_mint", MintBlock(MintType.BLUE, AbstractBlock.Settings.create().mapColor(MapColor.BLUE).noCollision().ticksRandomly().breakInstantly().sounds(CobblemonSounds.MINT_SOUNDS)))
+    @JvmField
+    val CYAN_MINT = create("cyan_mint", MintBlock(MintType.CYAN, AbstractBlock.Settings.create().mapColor(MapColor.CYAN).noCollision().ticksRandomly().breakInstantly().sounds(CobblemonSounds.MINT_SOUNDS)))
+    @JvmField
+    val PINK_MINT = create("pink_mint", MintBlock(MintType.PINK, AbstractBlock.Settings.create().mapColor(MapColor.PINK).noCollision().ticksRandomly().breakInstantly().sounds(CobblemonSounds.MINT_SOUNDS)))
+    @JvmField
+    val GREEN_MINT = create("green_mint", MintBlock(MintType.GREEN, AbstractBlock.Settings.create().mapColor(MapColor.GREEN).noCollision().ticksRandomly().breakInstantly().sounds(CobblemonSounds.MINT_SOUNDS)))
+    @JvmField
+    val WHITE_MINT = create("white_mint", MintBlock(MintType.WHITE, AbstractBlock.Settings.create().mapColor(MapColor.WHITE).noCollision().ticksRandomly().breakInstantly().sounds(CobblemonSounds.MINT_SOUNDS)))
+
+    @JvmField
+    val PASTURE = create(
+        "pasture",
+        PastureBlock(
+            AbstractBlock.Settings.create()
+                .mapColor(MapColor.BROWN)
+                .sounds(BlockSoundGroup.WOOD)
+                .strength(2F)
+                .nonOpaque()
+                .pistonBehavior(PistonBehavior.BLOCK)
+                .luminance { if ((it.get(PastureBlock.ON) as Boolean) && (it.get(PastureBlock.PART) == PastureBlock.PasturePart.TOP)) 10 else 0 }
+        )
+    )
+
+    @JvmField
+    val VIVICHOKE_SEEDS = this.create("vivichoke_seeds", VivichokeBlock(AbstractBlock.Settings.create().pistonBehavior(PistonBehavior.DESTROY).burnable().mapColor(MapColor.DARK_GREEN).noCollision().ticksRandomly().breakInstantly().sounds(CobblemonSounds.VIVICHOKE_SOUNDS)))
+    @JvmField
+    val PEP_UP_FLOWER = this.create("pep_up_flower", FlowerBlock(StatusEffects.LEVITATION, 10, AbstractBlock.Settings.create().mapColor(MapColor.DARK_GREEN).noCollision().breakInstantly().sounds(BlockSoundGroup.GRASS).offset(AbstractBlock.OffsetType.XZ).pistonBehavior(PistonBehavior.DESTROY)))
+    @JvmField
+    val POTTED_PEP_UP_FLOWER = this.create("potted_pep_up_flower", BlocksInvoker.createFlowerPotBlock(PEP_UP_FLOWER))
+
+    /**
+     * Returns a map of all the blocks that can be stripped with an axe in the format of input - output.
+     *
+     * @return A map of all the blocks that can be stripped with an axe in the format of input - output.
+     */
+    fun strippedBlocks(): Map<Block, Block> = mapOf(
+        APRICORN_WOOD to STRIPPED_APRICORN_WOOD,
+        APRICORN_LOG to STRIPPED_APRICORN_LOG
+    )
+
+
+
+    private fun apricornBlock(name: String, apricorn: Apricorn): ApricornBlock = this.create(name, ApricornBlock(AbstractBlock.Settings.create().mapColor(apricorn.mapColor()).ticksRandomly().strength(Blocks.OAK_LOG.hardness, Blocks.OAK_LOG.blastResistance).sounds(BlockSoundGroup.WOOD).nonOpaque(), apricorn))
+
+    private fun tumblestoneBlock(name: String, stage: Int, height: Int, xzOffset: Int, nextStage: Block?) : Block {
+        return this.create(name, TumblestoneBlock(AbstractBlock.Settings.create()
+            .pistonBehavior(PistonBehavior.DESTROY)
+            .nonOpaque()
+            .strength(1.5F)
+            .sounds(CobblemonSounds.TUMBLESTONE_SOUNDS),
+            stage, height, xzOffset, nextStage))
+    }
+
+    private val berries = mutableMapOf<Identifier, BerryBlock>()
+
+    val AGUAV_BERRY = this.berryBlock("aguav")
+    val APICOT_BERRY = this.berryBlock("apicot")
+    val ASPEAR_BERRY = this.berryBlock("aspear")
+    val BABIRI_BERRY = this.berryBlock("babiri")
+    val BELUE_BERRY = this.berryBlock("belue")
+    val BLUK_BERRY = this.berryBlock("bluk")
+    val CHARTI_BERRY = this.berryBlock("charti")
+    val CHERI_BERRY = this.berryBlock("cheri")
+    val CHESTO_BERRY = this.berryBlock("chesto")
+    val CHILAN_BERRY = this.berryBlock("chilan")
+    val CHOPLE_BERRY = this.berryBlock("chople")
+    val COBA_BERRY = this.berryBlock("coba")
+    val COLBUR_BERRY = this.berryBlock("colbur")
+    val CORNN_BERRY = this.berryBlock("cornn")
+    val CUSTAP_BERRY = this.berryBlock("custap")
+    val DURIN_BERRY = this.berryBlock("durin")
+    val ENIGMA_BERRY = this.berryBlock("enigma")
+    val FIGY_BERRY = this.berryBlock("figy")
+    val GANLON_BERRY = this.berryBlock("ganlon")
+    val GREPA_BERRY = this.berryBlock("grepa")
+    val HABAN_BERRY = this.berryBlock("haban")
+    val HONDEW_BERRY = this.berryBlock("hondew")
+    val HOPO_BERRY = this.berryBlock("hopo")
+    val IAPAPA_BERRY = this.berryBlock("iapapa")
+    val JABOCA_BERRY = this.berryBlock("jaboca")
+    val KASIB_BERRY = this.berryBlock("kasib")
+    val KEBIA_BERRY = this.berryBlock("kebia")
+    val KEE_BERRY = this.berryBlock("kee")
+    val KELPSY_BERRY = this.berryBlock("kelpsy")
+    val LANSAT_BERRY = this.berryBlock("lansat")
+    val LEPPA_BERRY = this.berryBlock("leppa")
+    val LIECHI_BERRY = this.berryBlock("liechi")
+    val LUM_BERRY = this.berryBlock("lum")
+    val MAGO_BERRY = this.berryBlock("mago")
+    val MAGOST_BERRY = this.berryBlock("magost")
+    val MARANGA_BERRY = this.berryBlock("maranga")
+    val MICLE_BERRY = this.berryBlock("micle")
+    val NANAB_BERRY = this.berryBlock("nanab")
+    val NOMEL_BERRY = this.berryBlock("nomel")
+    val OCCA_BERRY = this.berryBlock("occa")
+    val ORAN_BERRY = this.berryBlock("oran")
+    val PAMTRE_BERRY = this.berryBlock("pamtre")
+    val PASSHO_BERRY = this.berryBlock("passho")
+    val PAYAPA_BERRY = this.berryBlock("payapa")
+    val PECHA_BERRY = this.berryBlock("pecha")
+    val PERSIM_BERRY = this.berryBlock("persim")
+    val PETAYA_BERRY = this.berryBlock("petaya")
+    val PINAP_BERRY = this.berryBlock("pinap")
+    val POMEG_BERRY = this.berryBlock("pomeg")
+    val QUALOT_BERRY = this.berryBlock("qualot")
+    val RABUTA_BERRY = this.berryBlock("rabuta")
+    val RAWST_BERRY = this.berryBlock("rawst")
+    val RAZZ_BERRY = this.berryBlock("razz")
+    val RINDO_BERRY = this.berryBlock("rindo")
+    val ROSELI_BERRY = this.berryBlock("roseli")
+    val ROWAP_BERRY = this.berryBlock("rowap")
+    val SALAC_BERRY = this.berryBlock("salac")
+    val SHUCA_BERRY = this.berryBlock("shuca")
+    val SITRUS_BERRY = this.berryBlock("sitrus")
+    val SPELON_BERRY = this.berryBlock("spelon")
+    val STARF_BERRY = this.berryBlock("starf")
+    val TAMATO_BERRY = this.berryBlock("tamato")
+    val TANGA_BERRY = this.berryBlock("tanga")
+    val TOUGA_BERRY = this.berryBlock("touga")
+    val WACAN_BERRY = this.berryBlock("wacan")
+    val WATMEL_BERRY = this.berryBlock("watmel")
+    val WEPEAR_BERRY = this.berryBlock("wepear")
+    val WIKI_BERRY = this.berryBlock("wiki")
+    val YACHE_BERRY = this.berryBlock("yache")
+
+    init {
+        /**
+         * Makes all blocks in array flammable by adding them to FireBlock's flammableRegistry.
+         * second value is burn chance and third value is spread chance
+         */
+        arrayOf(
+            Triple(APRICORN_LOG, 5, 5),
+            Triple(STRIPPED_APRICORN_LOG, 5, 5),
+            Triple(APRICORN_WOOD, 5, 5),
+            Triple(STRIPPED_APRICORN_WOOD, 5, 5),
+            Triple(APRICORN_PLANKS, 5, 20),
+            Triple(APRICORN_LEAVES, 30, 60),
+            Triple(APRICORN_FENCE, 5, 20),
+            Triple(APRICORN_FENCE_GATE, 5, 20),
+            Triple(APRICORN_SLAB, 5, 20),
+            Triple(APRICORN_STAIRS, 5, 20)
+        ).onEach{ data -> setFlammable(data.first, data.second, data.third) }
+    }
+
+    fun berries() = this.berries.toMap()
+
+    private fun berryBlock(name: String): BerryBlock {
+        val identifier = cobblemonResource("${name}_berry")
+        val block = this.create(identifier.path, BerryBlock(identifier, AbstractBlock.Settings.copy(Blocks.WHEAT).dynamicBounds().sounds(CobblemonSounds.BERRY_BUSH_SOUNDS).strength(0.2F)))
+        this.berries[identifier] = block
+        return block
+    }
+
+    /**
+     * Calls helper method from Vanilla
+     */
+    private fun log(name: String, arg: MapColor = MapColor.DIRT_BROWN, arg2: MapColor = MapColor.DIRT_BROWN): PillarBlock {
+        val block = BlocksInvoker.createLogBlock(arg, arg2)
+        return this.create(name, block)
+    }
+
+    /**
+     * Method uses generic E in order to keep the block as the same return type.
+     * If E is not a block then it will not be set as flammable.
+     * Calls Vanilla implementation of registering a flammable block.
+     * Mixins looks cursed but it is java's fault.
+     */
+    private fun <E> setFlammable(block: E, burnChance: Int, spreadChance: Int): E {
+        if(block !is Block) return block
+
+        var fireBlock: FireBlock =  Blocks.FIRE as FireBlock
+        //Cursed Mixin stuff
+        (fireBlock as FireBlockInvoker).registerNewFlammableBlock(block as Block, burnChance, spreadChance)
+        return block
+    }
+
+    private fun evolutionStoneOre(name: String) = this.create(name, ExperienceDroppingBlock(AbstractBlock.Settings.copy(Blocks.IRON_ORE), UniformIntProvider.create(1, 2)))
+
+    private fun deepslateEvolutionStoneOre(name: String) = this.create(name, ExperienceDroppingBlock(AbstractBlock.Settings.copy(Blocks.DEEPSLATE_IRON_ORE), UniformIntProvider.create(1, 2)))
+
+    /**
+     * Helper method for creating leaves
+     * copied over from Vanilla
+     */
+    private fun leaves(name: String): LeavesBlock {
+        val block = BlocksInvoker.createLeavesBlock(BlockSoundGroup.GRASS)
+        return this.create(name, block)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonClientImplementation.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import net.minecraft.block.Block
+import net.minecraft.block.entity.BlockEntity
+import net.minecraft.block.entity.BlockEntityType
+import net.minecraft.client.color.block.BlockColorProvider
+import net.minecraft.client.color.item.ItemColorProvider
+import net.minecraft.client.model.TexturedModelData
+import net.minecraft.client.particle.ParticleFactory
+import net.minecraft.client.particle.SpriteProvider
+import net.minecraft.client.render.RenderLayer
+import net.minecraft.client.render.block.entity.BlockEntityRendererFactory
+import net.minecraft.client.render.entity.EntityRendererFactory
+import net.minecraft.client.render.entity.model.EntityModelLayer
+import net.minecraft.entity.Entity
+import net.minecraft.entity.EntityType
+import net.minecraft.item.Item
+import net.minecraft.particle.ParticleEffect
+import net.minecraft.particle.ParticleType
+import java.util.function.Supplier
+
+interface CobblemonClientImplementation {
+    fun registerLayer(modelLayer: EntityModelLayer, supplier: Supplier<TexturedModelData>)
+    fun <T : ParticleEffect> registerParticleFactory(
+        type: ParticleType<T>,
+        factory: (SpriteProvider) -> ParticleFactory<T>
+    )
+
+    fun registerBlockRenderType(layer: RenderLayer, vararg blocks: Block)
+
+    fun registerItemColors(provider: ItemColorProvider, vararg items: Item)
+
+    fun registerBlockColors(provider: BlockColorProvider, vararg blocks: Block)
+
+    fun <T : BlockEntity> registerBlockEntityRenderer(type: BlockEntityType<out T>, factory: BlockEntityRendererFactory<T>)
+
+    fun <T : Entity> registerEntityRenderer(type: EntityType<out T>, factory: EntityRendererFactory<T>)
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonCommands.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.command.*
+import com.mojang.brigadier.CommandDispatcher
+import net.minecraft.command.CommandRegistryAccess
+import net.minecraft.server.command.CommandManager
+import net.minecraft.server.command.ServerCommandSource
+
+object CobblemonCommands {
+    fun register(dispatcher: CommandDispatcher<ServerCommandSource>, registry: CommandRegistryAccess, selection: CommandManager.RegistrationEnvironment) {
+        SpawnPokemon.register(dispatcher)
+        GivePokemon.register(dispatcher)
+        TakePokemon.register(dispatcher)
+        ChangeScaleAndSize.register(dispatcher)
+        ChangeWalkSpeed.register(dispatcher)
+        TestCommand.register(dispatcher)
+        ReloadShowdownCommand.register(dispatcher)
+        ClickTextCommand.register(dispatcher)
+        PokemonEditCommand.register(dispatcher)
+        TeachCommand.register(dispatcher)
+        LevelUp.register(dispatcher)
+        HealPokemonCommand.register(dispatcher)
+        StopBattleCommand.register(dispatcher)
+        CheckSpawnsCommand.register(dispatcher)
+        GetNBT.register(dispatcher)
+        OpenStarterScreenCommand.register(dispatcher)
+        SpawnAllPokemon.register(dispatcher)
+        FriendshipCommand.register(dispatcher)
+        GiveAllPokemon.register(dispatcher)
+        HeldItemCommand.register(dispatcher, registry)
+        PcCommand.register(dispatcher)
+        SpawnPokemonFromPool.register(dispatcher)
+        PokeboxCommand.register(dispatcher)
+        TestStoreCommand.register(dispatcher)
+        QueryLearnsetCommand.register(dispatcher)
+        TestPcSlotCommand.register(dispatcher)
+        TestPartySlotCommand.register(dispatcher)
+        ClearPartyCommand.register(dispatcher)
+        ClearPCCommand.register(dispatcher)
+        PokemonRestartCommand.register(dispatcher)
+        BedrockParticleCommand.register(dispatcher)
+        OpenDialogueCommand.register(dispatcher)
+        NPCEditCommand.register(dispatcher)
+
+        // Possibly lock down registration if and only if under dev environment or running in an environment
+        // with a certain system environment variable set
+        CobblemonInfoCommand.register(dispatcher)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonEntities.kt

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.api.pokeball.PokeBalls
+import com.cobblemon.mod.common.entity.boat.CobblemonBoatEntity
+import com.cobblemon.mod.common.entity.boat.CobblemonChestBoatEntity
+import com.cobblemon.mod.common.entity.fishing.PokeRodFishingBobberEntity
+import com.cobblemon.mod.common.entity.npc.NPCEntity
+import com.cobblemon.mod.common.entity.generic.GenericBedrockEntity
+import com.cobblemon.mod.common.entity.pokeball.EmptyPokeBallEntity
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.platform.PlatformRegistry
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.entity.EntityType
+import net.minecraft.entity.LivingEntity
+import net.minecraft.entity.SpawnGroup
+import net.minecraft.entity.attribute.DefaultAttributeContainer
+import net.minecraft.registry.Registries
+import net.minecraft.registry.Registry
+import net.minecraft.registry.RegistryKey
+import net.minecraft.registry.RegistryKeys
+
+object CobblemonEntities : PlatformRegistry<Registry<EntityType<*>>, RegistryKey<Registry<EntityType<*>>>, EntityType<*>>() {
+
+
+    override val registry: Registry<EntityType<*>> = Registries.ENTITY_TYPE
+    override val registryKey: RegistryKey<Registry<EntityType<*>>> = RegistryKeys.ENTITY_TYPE
+    @JvmField
+    val POKEMON_KEY = cobblemonResource("pokemon")
+    @JvmField
+    val POKEMON: EntityType<PokemonEntity> = this.create(
+        POKEMON_KEY.path,
+        EntityType.Builder.create({ _, world -> PokemonEntity(world) }, SpawnGroup.CREATURE)
+            .build(POKEMON_KEY.toString())
+    )
+
+    @JvmField
+    val EMPTY_POKEBALL_KEY = cobblemonResource("empty_pokeball")
+    @JvmField
+    val EMPTY_POKEBALL: EntityType<EmptyPokeBallEntity> = this.create(
+        EMPTY_POKEBALL_KEY.path,
+        EntityType.Builder.create({ _, world -> EmptyPokeBallEntity(PokeBalls.POKE_BALL, world) }, SpawnGroup.MISC)
+            .build(EMPTY_POKEBALL_KEY.toString())
+    )
+
+    @JvmField
+    val BOAT_KEY = cobblemonResource("boat")
+    @JvmField
+    val BOAT: EntityType<CobblemonBoatEntity> = this.create(
+        BOAT_KEY.path,
+        EntityType.Builder.create(::CobblemonBoatEntity, SpawnGroup.MISC).setDimensions(1.375F, 0.5625F).maxTrackingRange(10)
+            .build(BOAT_KEY.toString())
+    )
+
+    @JvmField
+    val CHEST_BOAT_KEY = cobblemonResource("chest_boat")
+    @JvmField
+    val CHEST_BOAT: EntityType<CobblemonChestBoatEntity> = this.create(
+        CHEST_BOAT_KEY.path,
+        EntityType.Builder.create(::CobblemonChestBoatEntity, SpawnGroup.MISC).setDimensions(1.375F, 0.5625F).maxTrackingRange(10)
+            .build(CHEST_BOAT_KEY.toString())
+    )
+
+    @JvmField
+    val POKE_BOBBER_KEY = cobblemonResource("poke_bobber")
+    @JvmField
+    val POKE_BOBBER: EntityType<PokeRodFishingBobberEntity> = this.create(
+            POKE_BOBBER_KEY.path,
+            EntityType.Builder.create(::PokeRodFishingBobberEntity, SpawnGroup.MISC).setDimensions(0.5F, 0.5F).maxTrackingRange(10)
+                    .build(POKE_BOBBER_KEY.toString())
+    )
+
+    @JvmField
+    val GENERIC_BEDROCK_ENTITY_KEY = cobblemonResource("generic_bedrock")
+    @JvmField
+    val GENERIC_BEDROCK_ENTITY: EntityType<GenericBedrockEntity> = this.create(
+        GENERIC_BEDROCK_ENTITY_KEY.path,
+        EntityType.Builder.create({ _, world -> GenericBedrockEntity(world) }, SpawnGroup.MISC)
+            .build(GENERIC_BEDROCK_ENTITY_KEY.toString())
+    )
+
+    @JvmField
+    val NPC_KEY = cobblemonResource("npc")
+    @JvmField
+    val NPC: EntityType<NPCEntity> = create(
+        NPC_KEY.path,
+        EntityType.Builder.create({ _, world -> NPCEntity(world) }, SpawnGroup.CREATURE).build("$NPC_KEY")
+    )
+
+    fun registerAttributes(consumer: (EntityType<out LivingEntity>, DefaultAttributeContainer.Builder) -> Unit) {
+        consumer(POKEMON, PokemonEntity.createAttributes())
+        consumer(NPC, NPCEntity.createAttributes())
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonFlows.kt

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.bedrockk.molang.runtime.MoLangRuntime
+import com.bedrockk.molang.runtime.value.MoValue
+import com.cobblemon.mod.common.api.data.DataRegistry
+import com.cobblemon.mod.common.api.molang.ExpressionLike
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.api.scripting.CobblemonScripts
+import com.cobblemon.mod.common.util.asExpressionLike
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.endsWith
+import java.util.concurrent.ExecutionException
+import net.minecraft.resource.ResourceManager
+import net.minecraft.resource.ResourceType
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+/**
+ * Holds all the flows that are loaded from the server's data packs. A flow is foldered under the event identifier,
+ * which can be cobblemon's namespace but can also be minecraft or any other namespace someone has added hooks for.
+ * The value of the map is a list of MoLang scripts that will execute when that event occurs.
+ *
+ * @author Hiroku
+ * @since February 24th, 2024
+ */
+object CobblemonFlows : DataRegistry {
+    override val id = cobblemonResource("flows")
+    override val observable = SimpleObservable<CobblemonFlows>()
+    override val type = ResourceType.SERVER_DATA
+    override fun sync(player: ServerPlayerEntity) {}
+
+    val runtime by lazy { MoLangRuntime().setup() }
+
+    val clientFlows = hashMapOf<Identifier, MutableList<ExpressionLike>>()
+    val flows = hashMapOf<Identifier, MutableList<ExpressionLike>>()
+
+    override fun reload(manager: ResourceManager) {
+        val folderBeforeNameRegex = ".*\\/([^\\/]+)\\/[^\\/]+\$".toRegex()
+        manager.findResources("flows") { path -> path.endsWith(CobblemonScripts.MOLANG_EXTENSION) }.forEach { (identifier, resource) ->
+            resource.inputStream.use { stream ->
+                stream.bufferedReader().use { reader ->
+                    try {
+                        val expression = reader.readText().asExpressionLike()
+                        val event = folderBeforeNameRegex.find(identifier.path)?.groupValues?.get(1)
+                            ?: throw IllegalArgumentException("Invalid flow path: $identifier. Should have a folder structure that includes the name of the event being flowed.")
+                        if (identifier.path.startsWith("flows/client/")) {
+                            clientFlows.getOrPut(Identifier(identifier.namespace, event)) { mutableListOf() }.add(expression)
+                        } else {
+                            flows.getOrPut(Identifier(identifier.namespace, event)) { mutableListOf() }.add(expression)
+                        }
+                    } catch (exception: Exception) {
+                        throw ExecutionException("Error loading MoLang script for flow: $identifier", exception)
+                    }
+                }
+            }
+        }
+
+        Cobblemon.LOGGER.info("Loaded ${CobblemonScripts.scripts.size} flows and ${CobblemonScripts.clientScripts.size} client flows")
+        observable.emit(this)
+    }
+
+    fun run(eventIdentifier: Identifier, context: Map<String, MoValue>) {
+        flows[eventIdentifier]?.forEach { it.resolve(runtime, context) }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonImplementation.kt

@@ -0,0 +1,243 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.api.data.JsonDataRegistry
+import com.cobblemon.mod.common.api.net.ClientNetworkPacketHandler
+import com.cobblemon.mod.common.api.net.NetworkPacket
+import com.cobblemon.mod.common.api.net.ServerNetworkPacketHandler
+import com.mojang.brigadier.arguments.ArgumentType
+import kotlin.reflect.KClass
+import net.minecraft.advancement.criterion.Criterion
+import net.minecraft.block.ComposterBlock
+import net.minecraft.command.argument.serialize.ArgumentSerializer
+import net.minecraft.item.ItemConvertible
+import net.minecraft.network.PacketByteBuf
+import net.minecraft.network.listener.ClientPlayPacketListener
+import net.minecraft.network.packet.Packet
+import net.minecraft.registry.RegistryKey
+import net.minecraft.registry.tag.TagKey
+import net.minecraft.resource.ResourceManager
+import net.minecraft.resource.ResourceReloader
+import net.minecraft.resource.ResourceType
+import net.minecraft.server.MinecraftServer
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.text.Text
+import net.minecraft.util.Identifier
+import net.minecraft.world.GameRules
+import net.minecraft.world.biome.Biome
+import net.minecraft.world.gen.GenerationStep
+import net.minecraft.world.gen.feature.PlacedFeature
+
+interface CobblemonImplementation {
+    val modAPI: ModAPI
+
+    /**
+     *
+     */
+    val networkManager: NetworkManager
+
+    /**
+     * TODO
+     *
+     * @return
+     */
+    fun environment(): Environment
+
+    /**
+     * TODO
+     *
+     * @param id
+     * @return
+     */
+    fun isModInstalled(id: String): Boolean
+
+    /**
+     * TODO
+     *
+     */
+    fun registerPermissionValidator()
+
+    /**
+     * TODO
+     *
+     */
+    fun registerSoundEvents()
+
+    /**
+     * TODO
+     *
+     */
+    fun registerItems()
+
+    /**
+     * TODO
+     *
+     */
+    fun registerBlocks()
+
+    /**
+     * TODO
+     *
+     */
+    fun registerEntityTypes()
+
+    /**
+     * TODO
+     *
+     */
+    fun registerEntityAttributes()
+
+    /**
+     * TODO
+     *
+     */
+    fun registerBlockEntityTypes()
+
+    /**
+     * TODO
+     *
+     */
+    fun registerWorldGenFeatures()
+
+    fun registerParticles()
+
+    /**
+     * Add a feature to the current platform implementation.
+     *
+     * @param feature The [PlacedFeature] being added.
+     * @param step The [GenerationStep.Feature] of this feature.
+     * @param validTag The [TagKey] required by the [Biome] for this feature to generate in, if null all biomes are valid.
+     */
+    fun addFeatureToWorldGen(feature: RegistryKey<PlacedFeature>, step: GenerationStep.Feature, validTag: TagKey<Biome>?)
+
+    /**
+     * TODO
+     *
+     * @param A
+     * @param T
+     * @param identifier
+     * @param argumentClass
+     * @param serializer
+     */
+    fun <A : ArgumentType<*>, T : ArgumentSerializer.ArgumentTypeProperties<A>> registerCommandArgument(identifier: Identifier, argumentClass: KClass<A>, serializer: ArgumentSerializer<A, T>)
+
+    /**
+     * TODO
+     *
+     * @param T
+     * @param name
+     * @param category
+     * @param type
+     * @return
+     */
+    fun <T : GameRules.Rule<T>> registerGameRule(name: String, category: GameRules.Category, type: GameRules.Type<T>): GameRules.Key<T>
+
+    /**
+     * TODO
+     *
+     * @param T
+     * @param criteria
+     * @return
+     */
+    fun <T : Criterion<*>> registerCriteria(criteria: T): T
+
+    /**
+     * TODO
+     *
+     * @param identifier
+     * @param reloader
+     * @param type
+     * @param dependencies
+     */
+    fun registerResourceReloader(identifier: Identifier, reloader: ResourceReloader, type: ResourceType, dependencies: Collection<Identifier>)
+
+    /**
+     * TODO
+     *
+     * @return
+     */
+    fun server(): MinecraftServer?
+
+    /**
+     * Handles platform independent reloading of a [JsonDataRegistry].
+     *
+     * @param registry The [JsonDataRegistry] to reload.
+     * @param manager The [ResourceManager] to reload from.
+     */
+    fun <T> reloadJsonRegistry(registry: JsonDataRegistry<T>, manager: ResourceManager): HashMap<Identifier, T>
+
+    /**
+     * Registers an item to the [ComposterBlock].
+     *
+     * @param item The [ItemConvertible] being registered.
+     * @param chance The chance % of increasing the composter level, 0 to 1 expected.
+     */
+    fun registerCompostable(item: ItemConvertible, chance: Float)
+
+    /**
+     * Registers a builtin resource pack.
+     *
+     * @param id The unique [Identifier] of this pack.
+     * @param title The title displayed in the resource pack GUI, the description is still a part of the pack metadata.
+     * @param activationBehaviour The [ResourcePackActivationBehaviour] for this pack.
+     */
+    fun registerBuiltinResourcePack(id: Identifier, title: Text, activationBehaviour: ResourcePackActivationBehaviour)
+
+}
+
+enum class ResourcePackActivationBehaviour {
+
+    /**
+     * The resource pack will start disabled.
+     */
+    NORMAL,
+
+    /**
+     * The resource pack will start enabled.
+     */
+    DEFAULT_ENABLED,
+
+    /**
+     * The resource pack will always be enabled.
+     * The user can reorder it but cannot remove it.
+     */
+    ALWAYS_ENABLED;
+
+}
+
+enum class ModAPI {
+    FABRIC,
+    FORGE
+}
+
+interface NetworkManager {
+
+    fun registerClientBound()
+
+    fun registerServerBound()
+
+    fun <T: NetworkPacket<T>> createClientBound(identifier: Identifier, kClass: KClass<T>, encoder: (T, PacketByteBuf) -> Unit, decoder: (PacketByteBuf) -> T, handler: ClientNetworkPacketHandler<T>)
+
+    fun <T: NetworkPacket<T>> createServerBound(identifier: Identifier, kClass: KClass<T>, encoder: (T, PacketByteBuf) -> Unit, decoder: (PacketByteBuf) -> T, handler: ServerNetworkPacketHandler<T>)
+
+    fun sendPacketToPlayer(player: ServerPlayerEntity, packet: NetworkPacket<*>)
+
+    fun sendPacketToServer(packet: NetworkPacket<*>)
+
+    fun <T : NetworkPacket<*>> asVanillaClientBound(packet: T): Packet<ClientPlayPacketListener>
+
+}
+
+enum class Environment {
+
+    CLIENT,
+    SERVER
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonMechanics.kt

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.bedrockk.molang.Expression
+import com.cobblemon.mod.common.api.data.DataRegistry
+import com.cobblemon.mod.common.api.molang.ExpressionLike
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.mechanics.BerriesMechanic
+import com.cobblemon.mod.common.mechanics.PotionsMechanic
+import com.cobblemon.mod.common.mechanics.RemediesMechanic
+import com.cobblemon.mod.common.util.adapters.ExpressionAdapter
+import com.cobblemon.mod.common.util.adapters.ExpressionLikeAdapter
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.google.gson.GsonBuilder
+import net.minecraft.resource.ResourceManager
+import net.minecraft.resource.ResourceType
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+object CobblemonMechanics : DataRegistry {
+    override val id: Identifier = cobblemonResource("mechanics")
+    override val type = ResourceType.SERVER_DATA
+    override val observable = SimpleObservable<CobblemonMechanics>()
+    val gson = GsonBuilder()
+        .setPrettyPrinting()
+        .registerTypeAdapter(Expression::class.java, ExpressionAdapter)
+        .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
+        .create()
+
+    var remedies = RemediesMechanic()
+    var berries = BerriesMechanic()
+    var potions = PotionsMechanic()
+
+    override fun sync(player: ServerPlayerEntity) {}
+    override fun reload(manager: ResourceManager) {
+        remedies = loadMechanic(manager, "remedies", RemediesMechanic::class.java)
+        berries = loadMechanic(manager, "berries", BerriesMechanic::class.java)
+        potions = loadMechanic(manager, "potions", PotionsMechanic::class.java)
+    }
+
+    private fun <T> loadMechanic(manager: ResourceManager, name: String, clazz: Class<T>): T {
+        manager.getResourceOrThrow(cobblemonResource("mechanics/$name.json")).inputStream.use {
+            return gson.fromJson(it.reader(), clazz)
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonMemories.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.mojang.serialization.Codec
+import com.mojang.serialization.codecs.ListCodec
+import com.mojang.serialization.codecs.PrimitiveCodec
+import java.util.Optional
+import net.minecraft.entity.ai.brain.MemoryModuleType
+import net.minecraft.util.Uuids
+
+object CobblemonMemories {
+    val memories = mutableMapOf<String, MemoryModuleType<*>>()
+
+    val BATTLING_POKEMON = register("battling_pokemon", ListCodec(Uuids.INT_STREAM_CODEC))
+    val NPC_BATTLING = register("npc_battling", PrimitiveCodec.BOOL)
+
+    fun <U> register(id: String, codec: Codec<U>): MemoryModuleType<U> {
+        val memoryModule = MemoryModuleType(Optional.of(codec))
+        memories[id] = memoryModule
+        return memoryModule
+    }
+
+    fun <U> register(id: String): MemoryModuleType<U> {
+        val memoryModule = MemoryModuleType<U>(Optional.empty())
+        memories[id] = memoryModule
+        return memoryModule
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonNetwork.kt

@@ -0,0 +1,481 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.api.net.ClientNetworkPacketHandler
+import com.cobblemon.mod.common.api.net.NetworkPacket
+import com.cobblemon.mod.common.api.net.ServerNetworkPacketHandler
+import com.cobblemon.mod.common.client.net.PlayerInteractOptionsHandler
+import com.cobblemon.mod.common.client.net.SetClientPlayerDataHandler
+import com.cobblemon.mod.common.client.net.animation.PlayPoseableAnimationHandler
+import com.cobblemon.mod.common.client.net.battle.*
+import com.cobblemon.mod.common.client.net.callback.move.OpenMoveCallbackHandler
+import com.cobblemon.mod.common.client.net.callback.party.OpenPartyCallbackHandler
+import com.cobblemon.mod.common.client.net.callback.partymove.OpenPartyMoveCallbackHandler
+import com.cobblemon.mod.common.client.net.data.DataRegistrySyncPacketHandler
+import com.cobblemon.mod.common.client.net.data.UnlockReloadPacketHandler
+import com.cobblemon.mod.common.client.net.dialogue.DialogueClosedHandler
+import com.cobblemon.mod.common.client.net.dialogue.DialogueOpenedHandler
+import com.cobblemon.mod.common.client.net.effect.RunPosableMoLangHandler
+import com.cobblemon.mod.common.client.net.effect.SpawnSnowstormEntityParticleHandler
+import com.cobblemon.mod.common.client.net.effect.SpawnSnowstormParticleHandler
+import com.cobblemon.mod.common.client.net.gui.InteractPokemonUIPacketHandler
+import com.cobblemon.mod.common.client.net.gui.SummaryUIPacketHandler
+import com.cobblemon.mod.common.client.net.npc.CloseNPCEditorHandler
+import com.cobblemon.mod.common.client.net.npc.OpenNPCEditorHandler
+import com.cobblemon.mod.common.client.net.pasture.ClosePastureHandler
+import com.cobblemon.mod.common.client.net.pasture.OpenPastureHandler
+import com.cobblemon.mod.common.client.net.pasture.PokemonPasturedHandler
+import com.cobblemon.mod.common.client.net.pasture.PokemonUnpasturedHandler
+import com.cobblemon.mod.common.client.net.pokemon.update.PokemonUpdatePacketHandler
+import com.cobblemon.mod.common.client.net.settings.ServerSettingsPacketHandler
+import com.cobblemon.mod.common.client.net.sound.UnvalidatedPlaySoundS2CPacketHandler
+import com.cobblemon.mod.common.client.net.spawn.SpawnExtraDataEntityHandler
+import com.cobblemon.mod.common.client.net.starter.StarterUIPacketHandler
+import com.cobblemon.mod.common.client.net.storage.RemoveClientPokemonHandler
+import com.cobblemon.mod.common.client.net.storage.SwapClientPokemonHandler
+import com.cobblemon.mod.common.client.net.storage.party.InitializePartyHandler
+import com.cobblemon.mod.common.client.net.storage.party.MoveClientPartyPokemonHandler
+import com.cobblemon.mod.common.client.net.storage.party.SetPartyPokemonHandler
+import com.cobblemon.mod.common.client.net.storage.party.SetPartyReferenceHandler
+import com.cobblemon.mod.common.client.net.storage.pc.ClosePCHandler
+import com.cobblemon.mod.common.client.net.storage.pc.InitializePCHandler
+import com.cobblemon.mod.common.client.net.storage.pc.MoveClientPCPokemonHandler
+import com.cobblemon.mod.common.client.net.storage.pc.OpenPCHandler
+import com.cobblemon.mod.common.client.net.storage.pc.SetPCBoxPokemonHandler
+import com.cobblemon.mod.common.client.net.storage.pc.SetPCPokemonHandler
+import com.cobblemon.mod.common.client.net.toast.ToastPacketHandler
+import com.cobblemon.mod.common.client.net.trade.TradeAcceptanceChangedHandler
+import com.cobblemon.mod.common.client.net.trade.TradeCancelledHandler
+import com.cobblemon.mod.common.client.net.trade.TradeCompletedHandler
+import com.cobblemon.mod.common.client.net.trade.TradeOfferExpiredHandler
+import com.cobblemon.mod.common.client.net.trade.TradeOfferNotificationHandler
+import com.cobblemon.mod.common.client.net.trade.TradeStartedHandler
+import com.cobblemon.mod.common.client.net.trade.TradeUpdatedHandler
+import com.cobblemon.mod.common.net.messages.client.PlayerInteractOptionsPacket
+import com.cobblemon.mod.common.net.messages.client.animation.PlayPoseableAnimationPacket
+import com.cobblemon.mod.common.net.messages.client.battle.*
+import com.cobblemon.mod.common.net.messages.client.callback.OpenMoveCallbackPacket
+import com.cobblemon.mod.common.net.messages.client.callback.OpenPartyCallbackPacket
+import com.cobblemon.mod.common.net.messages.client.callback.OpenPartyMoveCallbackPacket
+import com.cobblemon.mod.common.net.messages.client.data.AbilityRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.BerryRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.FlowRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.GlobalSpeciesFeatureSyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.MovesRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.NPCRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.PropertiesCompletionRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.SpeciesFeatureAssignmentSyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.SpeciesRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.StandardSpeciesFeatureSyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.UnlockReloadPacket
+import com.cobblemon.mod.common.net.messages.client.data.*
+import com.cobblemon.mod.common.net.messages.client.dialogue.DialogueClosedPacket
+import com.cobblemon.mod.common.net.messages.client.dialogue.DialogueOpenedPacket
+import com.cobblemon.mod.common.net.messages.client.effect.RunPosableMoLangPacket
+import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormEntityParticlePacket
+import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormParticlePacket
+import com.cobblemon.mod.common.net.messages.client.fossil.FossilRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.fossil.NaturalMaterialRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.npc.CloseNPCEditorPacket
+import com.cobblemon.mod.common.net.messages.client.npc.OpenNPCEditorPacket
+import com.cobblemon.mod.common.net.messages.client.pasture.ClosePasturePacket
+import com.cobblemon.mod.common.net.messages.client.pasture.OpenPasturePacket
+import com.cobblemon.mod.common.net.messages.client.pasture.PokemonPasturedPacket
+import com.cobblemon.mod.common.net.messages.client.pasture.PokemonUnpasturedPacket
+import com.cobblemon.mod.common.net.messages.client.pokemon.update.*
+import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.AddEvolutionPacket
+import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.ClearEvolutionsPacket
+import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.RemoveEvolutionPacket
+import com.cobblemon.mod.common.net.messages.client.settings.ServerSettingsPacket
+import com.cobblemon.mod.common.net.messages.client.sound.UnvalidatedPlaySoundS2CPacket
+import com.cobblemon.mod.common.net.messages.client.spawn.SpawnGenericBedrockPacket
+import com.cobblemon.mod.common.net.messages.client.spawn.SpawnPokeballPacket
+import com.cobblemon.mod.common.net.messages.client.spawn.SpawnPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.starter.OpenStarterUIPacket
+import com.cobblemon.mod.common.net.messages.client.starter.SetClientPlayerDataPacket
+import com.cobblemon.mod.common.net.messages.client.storage.RemoveClientPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.storage.SwapClientPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.storage.party.InitializePartyPacket
+import com.cobblemon.mod.common.net.messages.client.storage.party.MoveClientPartyPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.storage.party.SetPartyPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.storage.party.SetPartyReferencePacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.ClosePCPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.InitializePCPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.MoveClientPCPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.OpenPCPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.SetPCBoxPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.SetPCPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.toast.ToastPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeAcceptanceChangedPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeCancelledPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeCompletedPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeOfferExpiredPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeOfferNotificationPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeStartedPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeUpdatedPacket
+import com.cobblemon.mod.common.net.messages.client.ui.InteractPokemonUIPacket
+import com.cobblemon.mod.common.net.messages.client.ui.SummaryUIPacket
+import com.cobblemon.mod.common.net.messages.server.BattleChallengePacket
+import com.cobblemon.mod.common.net.messages.server.BenchMovePacket
+import com.cobblemon.mod.common.net.messages.server.RequestMoveSwapPacket
+import com.cobblemon.mod.common.net.messages.server.RequestPlayerInteractionsPacket
+import com.cobblemon.mod.common.net.messages.server.SelectStarterPacket
+import com.cobblemon.mod.common.net.messages.server.SendOutPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.battle.BattleSelectActionsPacket
+import com.cobblemon.mod.common.net.messages.server.battle.RemoveSpectatorPacket
+import com.cobblemon.mod.common.net.messages.server.battle.SpectateBattlePacket
+import com.cobblemon.mod.common.net.messages.server.callback.move.MoveSelectCancelledPacket
+import com.cobblemon.mod.common.net.messages.server.callback.move.MoveSelectedPacket
+import com.cobblemon.mod.common.net.messages.server.callback.party.PartyPokemonSelectedPacket
+import com.cobblemon.mod.common.net.messages.server.callback.party.PartySelectCancelledPacket
+import com.cobblemon.mod.common.net.messages.server.callback.partymove.PartyMoveSelectCancelledPacket
+import com.cobblemon.mod.common.net.messages.server.callback.partymove.PartyPokemonMoveSelectedPacket
+import com.cobblemon.mod.common.net.messages.server.dialogue.EscapeDialoguePacket
+import com.cobblemon.mod.common.net.messages.server.dialogue.InputToDialoguePacket
+import com.cobblemon.mod.common.net.messages.server.npc.SaveNPCPacket
+import com.cobblemon.mod.common.net.messages.server.pasture.PasturePokemonPacket
+import com.cobblemon.mod.common.net.messages.server.pasture.UnpastureAllPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.pasture.UnpasturePokemonPacket
+import com.cobblemon.mod.common.net.messages.server.pokemon.interact.InteractPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetNicknamePacket
+import com.cobblemon.mod.common.net.messages.server.pokemon.update.evolution.AcceptEvolutionPacket
+import com.cobblemon.mod.common.net.messages.server.starter.RequestStarterScreenPacket
+import com.cobblemon.mod.common.net.messages.server.storage.SwapPCPartyPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.storage.party.MovePartyPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.storage.party.ReleasePartyPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.storage.party.SwapPartyPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.storage.pc.MovePCPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.storage.pc.MovePCPokemonToPartyPacket
+import com.cobblemon.mod.common.net.messages.server.storage.pc.MovePartyPokemonToPCPacket
+import com.cobblemon.mod.common.net.messages.server.storage.pc.ReleasePCPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.storage.pc.SwapPCPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.storage.pc.UnlinkPlayerFromPCPacket
+import com.cobblemon.mod.common.net.messages.server.trade.AcceptTradeRequestPacket
+import com.cobblemon.mod.common.net.messages.server.trade.CancelTradePacket
+import com.cobblemon.mod.common.net.messages.server.trade.ChangeTradeAcceptancePacket
+import com.cobblemon.mod.common.net.messages.server.trade.OfferTradePacket
+import com.cobblemon.mod.common.net.messages.server.trade.UpdateTradeOfferPacket
+import com.cobblemon.mod.common.net.serverhandling.ChallengeHandler
+import com.cobblemon.mod.common.net.serverhandling.RequestInteractionsHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.BattleSelectActionsHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.RemoveSpectatorHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.SpectateBattleHandler
+import com.cobblemon.mod.common.net.serverhandling.callback.move.MoveSelectCancelledHandler
+import com.cobblemon.mod.common.net.serverhandling.callback.move.MoveSelectedHandler
+import com.cobblemon.mod.common.net.serverhandling.callback.party.PartyPokemonSelectedHandler
+import com.cobblemon.mod.common.net.serverhandling.callback.party.PartySelectCancelledHandler
+import com.cobblemon.mod.common.net.serverhandling.callback.partymove.PartyMoveSelectCancelledHandler
+import com.cobblemon.mod.common.net.serverhandling.callback.partymove.PartyPokemonMoveSelectedHandler
+import com.cobblemon.mod.common.net.serverhandling.dialogue.EscapeDialogueHandler
+import com.cobblemon.mod.common.net.serverhandling.dialogue.InputToDialogueHandler
+import com.cobblemon.mod.common.net.serverhandling.evolution.AcceptEvolutionHandler
+import com.cobblemon.mod.common.net.serverhandling.npc.SaveNPCHandler
+import com.cobblemon.mod.common.net.serverhandling.pasture.PasturePokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.pasture.UnpastureAllPokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.pasture.UnpasturePokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.pokemon.interact.InteractPokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetNicknameHandler
+import com.cobblemon.mod.common.net.serverhandling.starter.RequestStarterScreenHandler
+import com.cobblemon.mod.common.net.serverhandling.starter.SelectStarterPacketHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.BenchMoveHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.RequestMoveSwapHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.SendOutPokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.SwapPCPartyPokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.party.MovePartyPokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.party.ReleasePCPokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.party.SwapPartyPokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.pc.MovePCPokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.pc.MovePCPokemonToPartyHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.pc.MovePartyPokemonToPCHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.pc.ReleasePartyPokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.pc.SwapPCPokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.pc.UnlinkPlayerFromPCHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.AcceptTradeRequestHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.CancelTradeHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.ChangeTradeAcceptanceHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.OfferTradeHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.UpdateTradeOfferHandler
+import com.cobblemon.mod.common.util.server
+import kotlin.reflect.KClass
+import net.minecraft.network.PacketByteBuf
+import net.minecraft.network.listener.ClientPlayPacketListener
+import net.minecraft.network.packet.Packet
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+/**
+ * Registers Cobblemon network packets.
+ *
+ * This class also contains short functions for dispatching our packets to a player, all players, or to the entire server.
+ *
+ * @author Hiroku, Licious
+ * @since November 27th, 2021
+ */
+object CobblemonNetwork : NetworkManager {
+
+    fun ServerPlayerEntity.sendPacket(packet: NetworkPacket<*>) = sendPacketToPlayer(this, packet)
+    fun sendToServer(packet: NetworkPacket<*>) = this.sendPacketToServer(packet)
+    fun sendToAllPlayers(packet: NetworkPacket<*>) = sendPacketToPlayers(server()!!.playerManager.playerList, packet)
+    fun sendPacketToPlayers(players: Iterable<ServerPlayerEntity>, packet: NetworkPacket<*>) = players.forEach { sendPacketToPlayer(it, packet) }
+
+    override fun registerClientBound() {
+        // Pokemon Update Packets
+        this.createClientBound(FriendshipUpdatePacket.ID, FriendshipUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(MoveSetUpdatePacket.ID, MoveSetUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(NatureUpdatePacket.ID, NatureUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(ShinyUpdatePacket.ID, ShinyUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(SpeciesUpdatePacket.ID, SpeciesUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(NicknameUpdatePacket.ID, NicknameUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(HealthUpdatePacket.ID, HealthUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(ExperienceUpdatePacket.ID, ExperienceUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(StatusUpdatePacket.ID, StatusUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(CaughtBallUpdatePacket.ID, CaughtBallUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(BenchedMovesUpdatePacket.ID, BenchedMovesUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(GenderUpdatePacket.ID, GenderUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(AspectsUpdatePacket.ID, AspectsUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(AbilityUpdatePacket.ID, AbilityUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(EVsUpdatePacket.ID, EVsUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(IVsUpdatePacket.ID, IVsUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(HeldItemUpdatePacket.ID, HeldItemUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(PokemonStateUpdatePacket.ID, PokemonStateUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(TetheringUpdatePacket.ID, TetheringUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(TradeableUpdatePacket.ID, TradeableUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(SpeciesFeatureUpdatePacket.ID, SpeciesFeatureUpdatePacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(OriginalTrainerUpdatePacket.ID, OriginalTrainerUpdatePacket::decode, PokemonUpdatePacketHandler())
+
+        // Evolution start
+        this.createClientBound(AddEvolutionPacket.ID, AddEvolutionPacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(ClearEvolutionsPacket.ID, ClearEvolutionsPacket::decode, PokemonUpdatePacketHandler())
+        this.createClientBound(RemoveEvolutionPacket.ID, RemoveEvolutionPacket::decode, PokemonUpdatePacketHandler())
+        // Evolution End
+
+        // Storage Packets
+        this.createClientBound(InitializePartyPacket.ID, InitializePartyPacket::decode, InitializePartyHandler)
+        this.createClientBound(SetPartyPokemonPacket.ID, SetPartyPokemonPacket::decode, SetPartyPokemonHandler)
+        this.createClientBound(MoveClientPartyPokemonPacket.ID, MoveClientPartyPokemonPacket::decode, MoveClientPartyPokemonHandler)
+        this.createClientBound(SetPartyReferencePacket.ID, SetPartyReferencePacket::decode, SetPartyReferenceHandler)
+
+        this.createClientBound(InitializePCPacket.ID, InitializePCPacket::decode, InitializePCHandler)
+        this.createClientBound(MoveClientPCPokemonPacket.ID, MoveClientPCPokemonPacket::decode, MoveClientPCPokemonHandler)
+        this.createClientBound(SetPCBoxPokemonPacket.ID, SetPCBoxPokemonPacket::decode, SetPCBoxPokemonHandler)
+        this.createClientBound(SetPCPokemonPacket.ID, SetPCPokemonPacket::decode, SetPCPokemonHandler)
+        this.createClientBound(OpenPCPacket.ID, OpenPCPacket::decode, OpenPCHandler)
+        this.createClientBound(ClosePCPacket.ID, ClosePCPacket::decode, ClosePCHandler)
+
+        this.createClientBound(SwapClientPokemonPacket.ID, SwapClientPokemonPacket::decode, SwapClientPokemonHandler)
+        this.createClientBound(RemoveClientPokemonPacket.ID, RemoveClientPokemonPacket::decode, RemoveClientPokemonHandler)
+
+        // UI Packets
+        this.createClientBound(SummaryUIPacket.ID, SummaryUIPacket::decode, SummaryUIPacketHandler)
+        this.createClientBound(InteractPokemonUIPacket.ID, InteractPokemonUIPacket::decode, InteractPokemonUIPacketHandler)
+        this.createClientBound(PlayerInteractOptionsPacket.ID, PlayerInteractOptionsPacket::decode, PlayerInteractOptionsHandler)
+
+        // Starter packets
+        this.createClientBound(OpenStarterUIPacket.ID, OpenStarterUIPacket::decode, StarterUIPacketHandler)
+        this.createClientBound(SetClientPlayerDataPacket.ID, SetClientPlayerDataPacket::decode, SetClientPlayerDataHandler)
+
+        // Battle packets
+        this.createClientBound(BattleEndPacket.ID, BattleEndPacket::decode, BattleEndHandler)
+        this.createClientBound(BattleInitializePacket.ID, BattleInitializePacket::decode, BattleInitializeHandler)
+        this.createClientBound(BattleQueueRequestPacket.ID, BattleQueueRequestPacket::decode, BattleQueueRequestHandler)
+        this.createClientBound(BattleFaintPacket.ID, BattleFaintPacket::decode, BattleFaintHandler)
+        this.createClientBound(BattleMakeChoicePacket.ID, BattleMakeChoicePacket::decode, BattleMakeChoiceHandler)
+        this.createClientBound(BattleHealthChangePacket.ID, BattleHealthChangePacket::decode, BattleHealthChangeHandler)
+        this.createClientBound(BattleSetTeamPokemonPacket.ID, BattleSetTeamPokemonPacket::decode, BattleSetTeamPokemonHandler)
+        this.createClientBound(BattleSwitchPokemonPacket.ID, BattleSwitchPokemonPacket::decode, BattleSwitchPokemonHandler)
+        this.createClientBound(BattleMessagePacket.ID, BattleMessagePacket::decode, BattleMessageHandler)
+        this.createClientBound(BattleCaptureStartPacket.ID, BattleCaptureStartPacket::decode, BattleCaptureStartHandler)
+        this.createClientBound(BattleCaptureEndPacket.ID, BattleCaptureEndPacket::decode, BattleCaptureEndHandler)
+        this.createClientBound(BattleCaptureShakePacket.ID, BattleCaptureShakePacket::decode, BattleCaptureShakeHandler)
+        this.createClientBound(BattleApplyPassResponsePacket.ID, BattleApplyPassResponsePacket::decode, BattleApplyPassResponseHandler)
+        this.createClientBound(BattleChallengeNotificationPacket.ID, BattleChallengeNotificationPacket::decode, BattleChallengeNotificationHandler)
+        this.createClientBound(BattleUpdateTeamPokemonPacket.ID, BattleUpdateTeamPokemonPacket::decode, BattleUpdateTeamPokemonHandler)
+        this.createClientBound(BattlePersistentStatusPacket.ID, BattlePersistentStatusPacket::decode, BattlePersistentStatusHandler)
+        this.createClientBound(BattleMadeInvalidChoicePacket.ID, BattleMadeInvalidChoicePacket::decode, BattleMadeInvalidChoiceHandler)
+        this.createClientBound(BattleMusicPacket.ID, BattleMusicPacket::decode, BattleMusicHandler)
+        this.createClientBound(BattleChallengeExpiredPacket.ID, BattleChallengeExpiredPacket::decode, BattleChallengeExpiredHandler)
+        this.createClientBound(BattleReplacePokemonPacket.ID, BattleReplacePokemonPacket::decode, BattleReplacePokemonHandler)
+        this.createClientBound(BattleTransformPokemonPacket.ID, BattleTransformPokemonPacket::decode, BattleTransformPokemonHandler)
+
+
+
+        // Settings packets
+        this.createClientBound(ServerSettingsPacket.ID, ServerSettingsPacket::decode, ServerSettingsPacketHandler)
+
+        // Data registries
+        this.createClientBound(AbilityRegistrySyncPacket.ID, AbilityRegistrySyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(MovesRegistrySyncPacket.ID, MovesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(SpeciesRegistrySyncPacket.ID, SpeciesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(PropertiesCompletionRegistrySyncPacket.ID, PropertiesCompletionRegistrySyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(NPCRegistrySyncPacket.ID, NPCRegistrySyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(UnlockReloadPacket.ID, UnlockReloadPacket::decode, UnlockReloadPacketHandler)
+        this.createClientBound(BerryRegistrySyncPacket.ID, BerryRegistrySyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(StandardSpeciesFeatureSyncPacket.ID, StandardSpeciesFeatureSyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(GlobalSpeciesFeatureSyncPacket.ID, GlobalSpeciesFeatureSyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(SpeciesFeatureAssignmentSyncPacket.ID, SpeciesFeatureAssignmentSyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(NaturalMaterialRegistrySyncPacket.ID, NaturalMaterialRegistrySyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(FossilRegistrySyncPacket.ID, FossilRegistrySyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(PokeRodRegistrySyncPacket.ID, PokeRodRegistrySyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(FlowRegistrySyncPacket.ID, FlowRegistrySyncPacket::decode, DataRegistrySyncPacketHandler())
+
+        // Effects
+        this.createClientBound(SpawnSnowstormParticlePacket.ID, SpawnSnowstormParticlePacket::decode, SpawnSnowstormParticleHandler)
+        this.createClientBound(SpawnSnowstormEntityParticlePacket.ID, SpawnSnowstormEntityParticlePacket::decode, SpawnSnowstormEntityParticleHandler)
+        this.createClientBound(RunPosableMoLangPacket.ID, RunPosableMoLangPacket::decode, RunPosableMoLangHandler)
+
+        // Hax
+        this.createClientBound(UnvalidatedPlaySoundS2CPacket.ID, UnvalidatedPlaySoundS2CPacket::decode, UnvalidatedPlaySoundS2CPacketHandler)
+        this.createClientBound(SpawnPokemonPacket.ID, SpawnPokemonPacket::decode, SpawnExtraDataEntityHandler())
+        this.createClientBound(SpawnPokeballPacket.ID, SpawnPokeballPacket::decode, SpawnExtraDataEntityHandler())
+        this.createClientBound(ToastPacket.ID, ToastPacket::decode, ToastPacketHandler)
+        this.createClientBound(SpawnGenericBedrockPacket.ID, SpawnGenericBedrockPacket::decode, SpawnExtraDataEntityHandler())
+
+        // Trade packets
+        this.createClientBound(TradeAcceptanceChangedPacket.ID, TradeAcceptanceChangedPacket::decode, TradeAcceptanceChangedHandler)
+        this.createClientBound(TradeCancelledPacket.ID, TradeCancelledPacket::decode, TradeCancelledHandler)
+        this.createClientBound(TradeCompletedPacket.ID, TradeCompletedPacket::decode, TradeCompletedHandler)
+        this.createClientBound(TradeUpdatedPacket.ID, TradeUpdatedPacket::decode, TradeUpdatedHandler)
+        this.createClientBound(TradeOfferNotificationPacket.ID, TradeOfferNotificationPacket::decode, TradeOfferNotificationHandler)
+        this.createClientBound(TradeOfferExpiredPacket.ID, TradeOfferExpiredPacket::decode, TradeOfferExpiredHandler)
+        this.createClientBound(TradeStartedPacket.ID, TradeStartedPacket::decode, TradeStartedHandler)
+
+        // Pasture
+        this.createClientBound(OpenPasturePacket.ID, OpenPasturePacket::decode, OpenPastureHandler)
+        this.createClientBound(ClosePasturePacket.ID, ClosePasturePacket::decode, ClosePastureHandler)
+        this.createClientBound(PokemonPasturedPacket.ID, PokemonPasturedPacket::decode, PokemonPasturedHandler)
+        this.createClientBound(PokemonUnpasturedPacket.ID, PokemonUnpasturedPacket::decode, PokemonUnpasturedHandler)
+
+        // Behaviours
+        this.createClientBound(PlayPoseableAnimationPacket.ID, PlayPoseableAnimationPacket::decode, PlayPoseableAnimationHandler)
+
+        // Move select packets
+        this.createClientBound(OpenMoveCallbackPacket.ID, OpenMoveCallbackPacket::decode, OpenMoveCallbackHandler)
+
+        // Party select packets
+        this.createClientBound(OpenPartyCallbackPacket.ID, OpenPartyCallbackPacket::decode, OpenPartyCallbackHandler)
+
+        // Party move select packets
+        this.createClientBound(OpenPartyMoveCallbackPacket.ID, OpenPartyMoveCallbackPacket::decode, OpenPartyMoveCallbackHandler)
+
+        // Dialogue packets
+        this.createClientBound(DialogueClosedPacket.ID, DialogueClosedPacket::decode, DialogueClosedHandler)
+        this.createClientBound(DialogueOpenedPacket.ID, DialogueOpenedPacket::decode, DialogueOpenedHandler)
+
+        // NPCs
+        this.createClientBound(CloseNPCEditorPacket.ID, CloseNPCEditorPacket::decode, CloseNPCEditorHandler)
+        this.createClientBound(OpenNPCEditorPacket.ID, OpenNPCEditorPacket::decode, OpenNPCEditorHandler)
+    }
+
+    override fun registerServerBound() {
+        // Pokemon Update Packets
+        this.createServerBound(SetNicknamePacket.ID, SetNicknamePacket::decode, SetNicknameHandler)
+
+        // Evolution Packets
+        this.createServerBound(AcceptEvolutionPacket.ID, AcceptEvolutionPacket::decode, AcceptEvolutionHandler)
+
+        // Interaction Packets
+        this.createServerBound(InteractPokemonPacket.ID, InteractPokemonPacket::decode, InteractPokemonHandler)
+        this.createServerBound(RequestPlayerInteractionsPacket.ID, RequestPlayerInteractionsPacket::decode, RequestInteractionsHandler)
+
+        // Storage Packets
+        this.createServerBound(SendOutPokemonPacket.ID, SendOutPokemonPacket::decode, SendOutPokemonHandler)
+        this.createServerBound(RequestMoveSwapPacket.ID, RequestMoveSwapPacket::decode, RequestMoveSwapHandler)
+        this.createServerBound(BenchMovePacket.ID, BenchMovePacket::decode, BenchMoveHandler)
+        this.createServerBound(BattleChallengePacket.ID, BattleChallengePacket::decode, ChallengeHandler)
+
+        this.createServerBound(MovePCPokemonToPartyPacket.ID, MovePCPokemonToPartyPacket::decode, MovePCPokemonToPartyHandler)
+        this.createServerBound(MovePartyPokemonToPCPacket.ID, MovePartyPokemonToPCPacket::decode, MovePartyPokemonToPCHandler)
+        this.createServerBound(ReleasePartyPokemonPacket.ID, ReleasePartyPokemonPacket::decode, ReleasePartyPokemonHandler)
+        this.createServerBound(ReleasePCPokemonPacket.ID, ReleasePCPokemonPacket::decode, ReleasePCPokemonHandler)
+        this.createServerBound(UnlinkPlayerFromPCPacket.ID, UnlinkPlayerFromPCPacket::decode, UnlinkPlayerFromPCHandler)
+
+        // Starter packets
+        this.createServerBound(SelectStarterPacket.ID, SelectStarterPacket::decode, SelectStarterPacketHandler)
+        this.createServerBound(RequestStarterScreenPacket.ID, RequestStarterScreenPacket::decode, RequestStarterScreenHandler)
+
+        this.createServerBound(SwapPCPokemonPacket.ID, SwapPCPokemonPacket::decode, SwapPCPokemonHandler)
+        this.createServerBound(SwapPartyPokemonPacket.ID, SwapPartyPokemonPacket::decode, SwapPartyPokemonHandler)
+
+        this.createServerBound(MovePCPokemonPacket.ID, MovePCPokemonPacket::decode, MovePCPokemonHandler)
+        this.createServerBound(MovePartyPokemonPacket.ID, MovePartyPokemonPacket::decode, MovePartyPokemonHandler)
+
+        this.createServerBound(SwapPCPartyPokemonPacket.ID, SwapPCPartyPokemonPacket::decode, SwapPCPartyPokemonHandler)
+
+        // Battle packets
+        this.createServerBound(BattleSelectActionsPacket.ID, BattleSelectActionsPacket::decode, BattleSelectActionsHandler)
+        this.createServerBound(SpectateBattlePacket.ID, SpectateBattlePacket::decode, SpectateBattleHandler)
+        this.createServerBound(RemoveSpectatorPacket.ID, RemoveSpectatorPacket::decode, RemoveSpectatorHandler)
+
+        // Trade
+        this.createServerBound(AcceptTradeRequestPacket.ID, AcceptTradeRequestPacket::decode, AcceptTradeRequestHandler)
+        this.createServerBound(CancelTradePacket.ID, CancelTradePacket::decode, CancelTradeHandler)
+        this.createServerBound(ChangeTradeAcceptancePacket.ID, ChangeTradeAcceptancePacket::decode, ChangeTradeAcceptanceHandler)
+        this.createServerBound(OfferTradePacket.ID, OfferTradePacket::decode, OfferTradeHandler)
+        this.createServerBound(UpdateTradeOfferPacket.ID, UpdateTradeOfferPacket::decode, UpdateTradeOfferHandler)
+
+        // Pasture
+        this.createServerBound(PasturePokemonPacket.ID, PasturePokemonPacket::decode, PasturePokemonHandler)
+        this.createServerBound(UnpasturePokemonPacket.ID, UnpasturePokemonPacket::decode, UnpasturePokemonHandler)
+        this.createServerBound(UnpastureAllPokemonPacket.ID, UnpastureAllPokemonPacket::decode, UnpastureAllPokemonHandler)
+
+        // Move select packets
+        this.createServerBound(MoveSelectedPacket.ID, MoveSelectedPacket::decode, MoveSelectedHandler)
+        this.createServerBound(MoveSelectCancelledPacket.ID, MoveSelectCancelledPacket::decode, MoveSelectCancelledHandler)
+
+        // Party select packets
+        this.createServerBound(PartyPokemonSelectedPacket.ID, PartyPokemonSelectedPacket::decode, PartyPokemonSelectedHandler)
+        this.createServerBound(PartySelectCancelledPacket.ID, PartySelectCancelledPacket::decode, PartySelectCancelledHandler)
+
+        // Party move select packets
+        this.createServerBound(PartyPokemonMoveSelectedPacket.ID, PartyPokemonMoveSelectedPacket::decode, PartyPokemonMoveSelectedHandler)
+        this.createServerBound(PartyMoveSelectCancelledPacket.ID, PartyMoveSelectCancelledPacket::decode, PartyMoveSelectCancelledHandler)
+
+        // Dialogue packets
+        this.createServerBound(EscapeDialoguePacket.ID, EscapeDialoguePacket::decode, EscapeDialogueHandler)
+        this.createServerBound(InputToDialoguePacket.ID, InputToDialoguePacket::decode, InputToDialogueHandler)
+
+        // NPC packets
+        this.createServerBound(SaveNPCPacket.ID, SaveNPCPacket::decode, SaveNPCHandler)
+    }
+
+    private inline fun <reified T : NetworkPacket<T>> createClientBound(identifier: Identifier, noinline decoder: (PacketByteBuf) -> T, handler: ClientNetworkPacketHandler<T>) {
+        Cobblemon.implementation.networkManager.createClientBound(identifier, T::class, { message, buffer -> message.encode(buffer) }, decoder, handler)
+    }
+
+    private inline fun <reified T : NetworkPacket<T>> createServerBound(identifier: Identifier, noinline decoder: (PacketByteBuf) -> T, handler: ServerNetworkPacketHandler<T>) {
+        Cobblemon.implementation.networkManager.createServerBound(identifier, T::class, { message, buffer -> message.encode(buffer) }, decoder, handler)
+    }
+
+    override fun <T : NetworkPacket<T>> createClientBound(
+        identifier: Identifier,
+        kClass: KClass<T>,
+        encoder: (T, PacketByteBuf) -> Unit,
+        decoder: (PacketByteBuf) -> T,
+        handler: ClientNetworkPacketHandler<T>
+    ) {
+        Cobblemon.implementation.networkManager.createClientBound(identifier, kClass, encoder, decoder, handler)
+    }
+
+    override fun <T : NetworkPacket<T>> createServerBound(
+        identifier: Identifier,
+        kClass: KClass<T>,
+        encoder: (T, PacketByteBuf) -> Unit,
+        decoder: (PacketByteBuf) -> T,
+        handler: ServerNetworkPacketHandler<T>
+    ) {
+        Cobblemon.implementation.networkManager.createServerBound(identifier, kClass, encoder, decoder, handler)
+    }
+
+    override fun sendPacketToPlayer(player: ServerPlayerEntity, packet: NetworkPacket<*>) = Cobblemon.implementation.networkManager.sendPacketToPlayer(player, packet)
+
+    override fun sendPacketToServer(packet: NetworkPacket<*>) = Cobblemon.implementation.networkManager.sendPacketToServer(packet)
+
+    override fun <T : NetworkPacket<*>> asVanillaClientBound(packet: T): Packet<ClientPlayPacketListener> = Cobblemon.implementation.networkManager.asVanillaClientBound(packet)
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonSensors.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.entity.sensor.BattlingPokemonSensor
+import com.cobblemon.mod.common.entity.sensor.NPCBattlingSensor
+import java.util.function.Supplier
+import net.minecraft.entity.Entity
+import net.minecraft.entity.ai.brain.sensor.Sensor
+import net.minecraft.entity.ai.brain.sensor.SensorType
+
+object CobblemonSensors {
+    val sensors = mutableMapOf<String, SensorType<*>>()
+
+    val NPC_BATTLING = register("npc_battling", ::NPCBattlingSensor)
+    val BATTLING_POKEMON = register("battling_pokemon", ::BattlingPokemonSensor)
+
+    fun <E : Entity, U : Sensor<E>> register(id: String, supplier: Supplier<U>): SensorType<U> {
+        val sensor = SensorType(supplier)
+        sensors[id] = sensor
+        return sensor
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonSounds.kt

@@ -0,0 +1,371 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.platform.PlatformRegistry
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.registry.Registries
+import net.minecraft.registry.Registry
+import net.minecraft.registry.RegistryKey
+import net.minecraft.registry.RegistryKeys
+import net.minecraft.sound.BlockSoundGroup
+import net.minecraft.sound.SoundEvent
+import net.minecraft.sound.SoundEvents
+
+object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, RegistryKey<Registry<SoundEvent>>, SoundEvent>() {
+
+    override val registry: Registry<SoundEvent> = Registries.SOUND_EVENT
+    override val registryKey: RegistryKey<Registry<SoundEvent>> = RegistryKeys.SOUND_EVENT
+
+    @JvmField
+    val GUI_CLICK = this.create("gui.click")
+
+    @JvmField
+    val PC_ON = this.create("pc.on")
+    @JvmField
+    val PC_OFF = this.create("pc.off")
+    @JvmField
+    val PC_GRAB = this.create("pc.grab")
+    @JvmField
+    val PC_DROP = this.create("pc.drop")
+    @JvmField
+    val PC_RELEASE = this.create("pc.release")
+    @JvmField
+    val PC_CLICK = this.create("pc.click")
+
+    @JvmField
+    val HEALING_MACHINE_ACTIVE = this.create("healing_machine.active")
+
+    @JvmField
+    val POKE_BALL_CAPTURE_STARTED = this.create("poke_ball.capture_started")
+    @JvmField
+    val POKE_BALL_CAPTURE_SUCCEEDED = this.create("poke_ball.capture_succeeded")
+    @JvmField
+    val POKE_BALL_SHAKE = this.create("poke_ball.shake")
+    @JvmField
+    val POKE_BALL_OPEN = this.create("poke_ball.open")
+    @JvmField
+    val POKE_BALL_HIT = this.create("poke_ball.hit")
+    @JvmField
+    val POKE_BALL_SEND_OUT = this.create("poke_ball.send_out")
+    @JvmField
+    val POKE_BALL_RECALL = this.create("poke_ball.recall")
+    @JvmField
+    val POKE_BALL_THROW = this.create("poke_ball.throw")
+    @JvmField
+    val POKE_BALL_TRAIL = this.create("poke_ball.trail")
+
+    @JvmField
+    val ITEM_USE = this.create("item.use")
+    @JvmField
+    val CAN_EVOLVE = this.create("pokemon.can_evolve")
+    @JvmField
+    val EVOLVING = this.create("pokemon.evolving")
+    @JvmField
+    val EVOLVE = this.create("evolution.evolve")
+
+    @JvmField
+    val PVN_BATTLE = this.create("battle.pvn.default")
+    @JvmField
+    val PVP_BATTLE = this.create("battle.pvp.default")
+    @JvmField
+    val PVW_BATTLE = this.create("battle.pvw.default")
+
+    @JvmField
+    val MEDICINE_HERB_USE = this.create("medicine_herb.use")
+    @JvmField
+    val MEDICINE_LIQUID_USE = this.create("medicine_liquid.use")
+    @JvmField
+    val MEDICINE_PILLS_USE = this.create("medicine_pills.use")
+    @JvmField
+    val MEDICINE_SPRAY_USE = this.create("medicine_spray.use")
+    @JvmField
+    val MEDICINE_FEATHER_USE = this.create("medicine_feather.use")
+
+    @JvmField
+    val BERRY_HARVEST = this.create("berry.harvest")
+    @JvmField
+    val BERRY_EAT = this.create("berry.eat")
+
+    @JvmField
+    val MULCH_PLACE = this.create("mulch.place")
+    @JvmField
+    val MULCH_REMOVE = this.create("mulch.remove")
+
+    @JvmField
+    val FOSSIL_MACHINE_ACTIVATE = this.create("fossil_machine.activate")
+    @JvmField
+    val FOSSIL_MACHINE_ACTIVE_LOOP = this.create("fossil_machine.active_loop")
+    @JvmField
+    val FOSSIL_MACHINE_ASSEMBLE = this.create("fossil_machine.assemble")
+    @JvmField
+    val FOSSIL_MACHINE_DNA_FULL = this.create("fossil_machine.dna_full")
+    @JvmField
+    val FOSSIL_MACHINE_FINISHED = this.create("fossil_machine.finished")
+    @JvmField
+    val FOSSIL_MACHINE_INSERT_DNA = this.create("fossil_machine.insert_dna")
+    @JvmField
+    val FOSSIL_MACHINE_INSERT_DNA_SMALL = this.create("fossil_machine.insert_dna_small")
+    @JvmField
+    val FOSSIL_MACHINE_INSERT_FOSSIL = this.create("fossil_machine.insert_fossil")
+    @JvmField
+    val FOSSIL_MACHINE_RETRIEVE_FOSSIL = this.create("fossil_machine.retrieve_fossil")
+    @JvmField
+    val FOSSIL_MACHINE_RETRIEVE_POKEMON = this.create("fossil_machine.retrieve_pokemon")
+    @JvmField
+    val FOSSIL_MACHINE_UNPROTECTED = this.create("fossil_machine.unprotected")
+
+    @JvmField
+    val RELIC_COIN_SACK_BREAK = this.create("relic_coin_sack.break")
+    @JvmField
+    val RELIC_COIN_SACK_HIT = this.create("relic_coin_sack.hit")
+    @JvmField
+    val RELIC_COIN_SACK_STEP = this.create("relic_coin_sack.step")
+    @JvmField
+    val RELIC_COIN_SACK_PLACE = this.create("relic_coin_sack.place")
+    @JvmField
+    val RELIC_COIN_POUCH_BREAK = this.create("relic_coin_pouch.break")
+    @JvmField
+    val RELIC_COIN_POUCH_PLACE = this.create("relic_coin_pouch.place")
+
+    @JvmField
+    val FISHING_NOTIFICATION = this.create("fishing.notification")
+    @JvmField
+    val FISHING_SPLASH_BIG = this.create("fishing.splash_big")
+    @JvmField
+    val FISHING_SPLASH_SMALL = this.create("fishing.splash_small")
+    @JvmField
+    val FISHING_BOBBER_LAND = this.create("fishing.bobber_land")
+    @JvmField
+    val TUMBLESTONE_BREAK = this.create("tumblestone.break")
+    @JvmField
+    val TUMBLESTONE_BLOCK_BREAK = this.create("tumblestone.block_break")
+    @JvmField
+    val TUMBLESTONE_HIT = this.create("tumblestone.hit")
+    @JvmField
+    val TUMBLESTONE_PLACE = this.create("tumblestone.place")
+    @JvmField
+    val TUMBLESTONE_STEP = this.create("tumblestone.step")
+
+    @JvmField
+    val GIMMIGHOUL_GIVE_ITEM_SMALL = this.create("gimmighoul.give_item_small")
+    @JvmField
+    val GIMMIGHOUL_REVEAL = this.create("gimmighoul.reveal")
+
+    @JvmField
+    val BERRY_BUSH_BREAK = this.create("berry_bush.break")
+    @JvmField
+    val BERRY_BUSH_PLACE = this.create("berry_bush.place")
+
+    @JvmField
+    val BIG_ROOT_BREAK = this.create("big_root.break")
+    @JvmField
+    val ENERGY_ROOT_PLACE = this.create("energy_root.place")
+
+    @JvmField
+    val VIVICHOKE_BREAK = this.create("vivichoke.break")
+    @JvmField
+    val VIVICHOKE_PLACE = this.create("vivichoke.place")
+
+    @JvmField
+    val MINT_BREAK = this.create("mint.break")
+    @JvmField
+    val MINT_PLACE = this.create("mint.place")
+
+    @JvmField
+    val REVIVAL_HERB_BREAK = this.create("revival_herb.break")
+    @JvmField
+    val REVIVAL_HERB_PLACE = this.create("revival_herb.place")
+
+    @JvmField
+    val MEDICINAL_LEEK_BREAK = this.create("medicinal_leek.break")
+    @JvmField
+    val MEDICINAL_LEEK_PLACE = this.create("medicinal_leek.plant")
+
+    @JvmField
+    val GILDED_CHEST_OPEN = this.create("gilded_chest.open")
+    @JvmField
+    val GILDED_CHEST_CLOSE = this.create("gilded_chest.close")
+    @JvmField
+    val GILDED_CHEST_STEP = this.create("gilded_chest.step")
+    @JvmField
+    val GILDED_CHEST_HIT = this.create("gilded_chest.hit")
+    @JvmField
+    val GILDED_CHEST_BREAK = this.create("gilded_chest.break")
+    @JvmField
+    val GILDED_CHEST_PLACE = this.create("gilded_chest.place")
+
+    @JvmField
+    val RELIC_COIN_SACK_SOUNDS = BlockSoundGroup(1f, 1f,
+        RELIC_COIN_SACK_BREAK,
+        RELIC_COIN_SACK_STEP,
+        RELIC_COIN_SACK_PLACE,
+        RELIC_COIN_SACK_HIT,
+        RELIC_COIN_SACK_STEP
+    )
+    @JvmField
+    val RELIC_COIN_POUCH_SOUNDS = BlockSoundGroup(1f, 1f,
+        RELIC_COIN_POUCH_BREAK,
+        RELIC_COIN_SACK_STEP,
+        RELIC_COIN_POUCH_PLACE,
+        RELIC_COIN_SACK_HIT,
+        RELIC_COIN_SACK_STEP
+    )
+
+    @JvmField
+    val IMPACT_NORMAL = this.create("impact.normal")
+    @JvmField
+    val IMPACT_BUG = this.create("impact.bug")
+    @JvmField
+    val IMPACT_DARK = this.create("impact.dark")
+    @JvmField
+    val IMPACT_DRAGON = this.create("impact.dragon")
+    @JvmField
+    val IMPACT_ELECTRIC = this.create("impact.electric")
+    @JvmField
+    val IMPACT_FAIRY = this.create("impact.fairy")
+    @JvmField
+    val IMPACT_FIGHTING = this.create("impact.fighting")
+    @JvmField
+    val IMPACT_FIRE = this.create("impact.fire")
+    @JvmField
+    val IMPACT_FLYING = this.create("impact.flying")
+    @JvmField
+    val IMPACT_GHOST = this.create("impact.ghost")
+    @JvmField
+    val IMPACT_GRASS = this.create("impact.grass")
+    @JvmField
+    val IMPACT_GROUND = this.create("impact.ground")
+    @JvmField
+    val IMPACT_ICE = this.create("impact.ice")
+    @JvmField
+    val IMPACT_POISON = this.create("impact.poison")
+    @JvmField
+    val IMPACT_PSYCHIC = this.create("impact.psychic")
+    @JvmField
+    val IMPACT_ROCK = this.create("impact.rock")
+    @JvmField
+    val IMPACT_STEEL = this.create("impact.steel")
+    @JvmField
+    val IMPACT_WATER = this.create("impact.water")
+
+    @JvmField
+    val TUMBLESTONE_SOUNDS = BlockSoundGroup(1f, 1f,
+        TUMBLESTONE_BREAK,
+        TUMBLESTONE_STEP,
+        TUMBLESTONE_PLACE,
+        TUMBLESTONE_HIT,
+        TUMBLESTONE_STEP
+    )
+
+    @JvmField
+    val TUMBLESTONE_BLOCK_SOUNDS = BlockSoundGroup(1f, 1f,
+        TUMBLESTONE_BLOCK_BREAK,
+        TUMBLESTONE_STEP,
+        TUMBLESTONE_PLACE,
+        TUMBLESTONE_HIT,
+        TUMBLESTONE_STEP
+    )
+
+    @JvmField
+    val BERRY_BUSH_SOUNDS = BlockSoundGroup(1f, 1f,
+        BERRY_BUSH_BREAK,
+        SoundEvents.BLOCK_GRASS_STEP,
+        BERRY_BUSH_PLACE,
+        SoundEvents.BLOCK_GRASS_HIT,
+        SoundEvents.BLOCK_GRASS_STEP
+    )
+
+    @JvmField
+    val BIG_ROOT_SOUNDS = BlockSoundGroup(1f, 1f,
+        BIG_ROOT_BREAK,
+        SoundEvents.BLOCK_ROOTS_STEP,
+        SoundEvents.BLOCK_ROOTS_PLACE,
+        SoundEvents.BLOCK_ROOTS_HIT,
+        SoundEvents.BLOCK_ROOTS_FALL
+    )
+
+    @JvmField
+    val ENERGY_ROOT_SOUNDS = BlockSoundGroup(1f, 1f,
+        SoundEvents.BLOCK_ROOTS_BREAK,
+        SoundEvents.BLOCK_ROOTS_STEP,
+        ENERGY_ROOT_PLACE,
+        SoundEvents.BLOCK_ROOTS_HIT,
+        SoundEvents.BLOCK_ROOTS_FALL
+    )
+
+    @JvmField
+    val MEDICINAL_LEEK_SOUNDS = BlockSoundGroup(1f, 1f,
+        MEDICINAL_LEEK_BREAK,
+        SoundEvents.BLOCK_GRASS_STEP,
+        MEDICINAL_LEEK_PLACE,
+        SoundEvents.BLOCK_GRASS_HIT,
+        SoundEvents.BLOCK_GRASS_FALL
+    )
+
+    @JvmField
+    val VIVICHOKE_SOUNDS = BlockSoundGroup(1f, 1f,
+        VIVICHOKE_BREAK,
+        SoundEvents.BLOCK_GRASS_STEP,
+        VIVICHOKE_PLACE,
+        SoundEvents.BLOCK_GRASS_HIT,
+        SoundEvents.BLOCK_GRASS_FALL
+    )
+
+    @JvmField
+    val MINT_SOUNDS = BlockSoundGroup(1f, 1f,
+        MINT_BREAK,
+        SoundEvents.BLOCK_GRASS_STEP,
+        MINT_PLACE,
+        SoundEvents.BLOCK_GRASS_HIT,
+        SoundEvents.BLOCK_GRASS_FALL
+    )
+
+    @JvmField
+    val REVIVAL_HERB_SOUNDS = BlockSoundGroup(1f, 1f,
+        REVIVAL_HERB_BREAK,
+        SoundEvents.BLOCK_GRASS_STEP,
+        REVIVAL_HERB_PLACE,
+        SoundEvents.BLOCK_GRASS_HIT,
+        SoundEvents.BLOCK_GRASS_FALL
+    )
+
+    @JvmField
+    val GILDED_CHEST_SOUNDS = BlockSoundGroup(1f, 1f,
+        GILDED_CHEST_BREAK,
+        GILDED_CHEST_STEP,
+        GILDED_CHEST_PLACE,
+        GILDED_CHEST_HIT,
+        GILDED_CHEST_STEP
+    )
+
+    @JvmField
+    val DISPLAY_CASE_ADD_ITEM = this.create("display_case.add_item")
+    @JvmField
+    val DISPLAY_CASE_REMOVE_ITEM = this.create("display_case.remove_item")
+    @JvmField
+    val DISPLAY_CASE_BREAK = this.create("display_case.break")
+    @JvmField
+    val DISPLAY_CASE_HIT = this.create("display_case.hit")
+    @JvmField
+    val DISPLAY_CASE_PLACE = this.create("display_case.place")
+    @JvmField
+    val DISPLAY_CASE_STEP = this.create("display_case.step")
+
+    @JvmField
+    val DISPLAY_CASE_SOUNDS = BlockSoundGroup(1f, 1f,
+        DISPLAY_CASE_BREAK,
+        DISPLAY_CASE_STEP,
+        DISPLAY_CASE_PLACE,
+        DISPLAY_CASE_HIT,
+        DISPLAY_CASE_STEP
+    )
+
+    private fun create(name: String): SoundEvent = this.create(name, SoundEvent.of(cobblemonResource(name)))
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonTradeOffers.kt

@@ -0,0 +1,99 @@
+/*
+ * 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.registry.Registries
+import net.minecraft.village.TradeOffers
+import net.minecraft.village.VillagerData
+import net.minecraft.village.VillagerProfession
+
+/**
+ * A generator for various trade offers in the mod.
+ */
+object CobblemonTradeOffers {
+
+    /**
+     * Creates a list of all Cobblemon trade offers for every villager profession.
+     *
+     * @return The resulting list.
+     */
+    fun tradeOffersForAll(): List<VillagerTradeOffer> = Registries.VILLAGER_PROFESSION.map(this::tradeOffersFor).flatten()
+
+    /**
+     * Creates a list of all Cobblemon trade offers for the given [VillagerProfession].
+     *
+     * @param profession The [VillagerProfession] being queried.
+     * @return The resulting list.
+     */
+    fun tradeOffersFor(profession: VillagerProfession): List<VillagerTradeOffer> = when (profession) {
+        VillagerProfession.FARMER -> listOf(
+            VillagerTradeOffer(VillagerProfession.FARMER, 3, listOf(TradeOffers.SellItemFactory(CobblemonItems.VIVICHOKE_SEEDS, 24, 1, 1, 6)))
+        )
+        VillagerProfession.FISHERMAN -> listOf(
+            VillagerTradeOffer(VillagerProfession.FISHERMAN, 5, listOf(
+                TradeOffers.SellItemFactory(CobblemonItems.POKEROD_SMITHING_TEMPLATE, 12, 3, 30)
+            ))
+        )
+        else -> emptyList()
+    }
+
+    /**
+     * Creates a list of all Cobblemon trade offers for the Wandering trader.
+     *
+     * @return The resulting list.
+     */
+    fun resolveWanderingTradeOffers(): List<WandererTradeOffer> = listOf(
+        WandererTradeOffer(false, listOf(TradeOffers.SellItemFactory(CobblemonItems.VIVICHOKE_SEEDS, 24, 1, 1, 6)))
+    )
+
+    /**
+     * Represents a trade offer that can be attached to a villager or a wandering trader.
+     */
+    interface TradeOfferHolder {
+        /**
+         * The list of the possible [TradeOffers.Factory].
+         */
+        val tradeOffers: List<TradeOffers.Factory>
+    }
+
+    /**
+     * Represents a trade offer from a villager.
+     *
+     * @property profession The target profession for this trade.
+     * @property requiredLevel The level required must be a possible level.
+     * @property tradeOffers The list of the possible [TradeOffers.Factory].
+     *
+     * @throws IllegalArgumentException If the [requiredLevel] is not within the bounds of [VillagerData.MIN_LEVEL] & [VillagerData.MAX_LEVEL].
+     */
+    data class VillagerTradeOffer(
+        val profession: VillagerProfession,
+        val requiredLevel: Int,
+        override val tradeOffers: List<TradeOffers.Factory>
+    ) : TradeOfferHolder {
+
+        init {
+            if (this.requiredLevel < VillagerData.MIN_LEVEL || this.requiredLevel > VillagerData.MAX_LEVEL) {
+                throw IllegalArgumentException("${this.requiredLevel} is not a valid level for a villager trade accepted range is ${VillagerData.MIN_LEVEL}-${VillagerData.MAX_LEVEL}")
+            }
+        }
+
+    }
+
+    /**
+     * Represents a trade offer from a wandering trader.
+     *
+     * @property isRareTrade If this is rare or common trade.
+     * @property tradeOffers The list of the possible [TradeOffers.Factory].
+     */
+    data class WandererTradeOffer(
+        val isRareTrade: Boolean,
+        override val tradeOffers: List<TradeOffers.Factory>
+    ) : TradeOfferHolder
+    
+}

common/src/main/kotlin/com/cobblemon/mod/common/advancement/CobblemonCriteria.kt

@@ -0,0 +1,133 @@
+/*
+ * 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.advancement
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.advancement.criterion.*
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.advancement.criterion.Criterion
+
+/**
+ * Contains all the advancement criteria in Cobblemon.
+ *
+ * @author Licious
+ * @since October 26th, 2022
+ */
+object CobblemonCriteria {
+    val PICK_STARTER = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("pick_starter"),
+            PickStarterCriterionCondition::class.java
+        )
+    )
+    val CATCH_POKEMON = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("catch_pokemon"),
+            CaughtPokemonCriterionCondition::class.java
+        )
+    )
+    val CATCH_SHINY_POKEMON = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("catch_shiny_pokemon"),
+            SimpleCountableCriterionCondition::class.java
+        )
+    )
+    val EGG_HATCH = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("eggs_hatched"),
+            SimpleCountableCriterionCondition::class.java
+        )
+    )
+    val EVOLVE_POKEMON = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("pokemon_evolved"),
+            EvolvePokemonCriterionCondition::class.java
+        )
+    )
+    val WIN_BATTLE = this.create(
+        BattleCountableCriterionTrigger(
+            cobblemonResource("battles_won"),
+            BattleCountableCriterionCondition::class.java
+        )
+    )
+
+    val DEFEAT_POKEMON = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("pokemon_defeated"),
+            SimpleCountableCriterionCondition::class.java
+        )
+    )
+
+    val COLLECT_ASPECT = this.create(
+        AspectCriterionTrigger(
+            cobblemonResource("aspects_collected"),
+            AspectCriterionCondition::class.java
+        )
+    )
+
+    val POKEMON_INTERACT = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("pokemon_interact"),
+            PokemonInteractCriterion::class.java
+        )
+    )
+
+    val PARTY_CHECK = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("party"),
+            PartyCheckCriterion::class.java
+        )
+    )
+
+    val LEVEL_UP = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("level_up"),
+            LevelUpCriterionCondition::class.java
+        )
+    )
+
+    val PASTURE_USE = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("pasture_use"),
+            PickStarterCriterionCondition::class.java
+        )
+    )
+
+    val RESURRECT_POKEMON = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("resurrect_pokemon"),
+            PickStarterCriterionCondition::class.java
+        )
+    )
+
+    val TRADE_POKEMON = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("trade_pokemon"),
+            TradePokemonCriterionCondition::class.java
+        )
+    )
+
+    val CAST_POKE_ROD = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("cast_poke_rod"),
+            CastPokeRodCriterionCondition::class.java
+        )
+    )
+
+    // Advancement criteria for [grow_tumblestone.json]
+    val PLANT_TUMBLESTONE = this.create(
+        SimpleCriterionTrigger(
+            cobblemonResource("plant_tumblestone"),
+            PlantTumblestoneCriterionCondition::class.java
+        )
+    )
+
+    private fun <T : Criterion<*>> create(criteria: T): T = Cobblemon.implementation.registerCriteria(criteria)
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/AspectCriterion.kt

@@ -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.advancement.criterion
+
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.google.gson.JsonArray
+import com.google.gson.JsonObject
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+open class AspectCriterionTrigger(identifier: Identifier, criterionClass: Class<AspectCriterionCondition>) : SimpleCriterionTrigger<MutableMap<Identifier, MutableSet<String>>, AspectCriterionCondition>(identifier, criterionClass) {
+
+}
+
+class AspectCriterionCondition(id: Identifier, predicate: LootContextPredicate) : SimpleCriterionCondition<MutableMap<Identifier, MutableSet<String>>>(id, predicate) {
+    var pokemon = Identifier("cobblemon:pikachu")
+    var aspects = mutableListOf<String>()
+    override fun toJson(json: JsonObject) {
+        json.add("aspects", JsonArray(aspects.size).also {
+            aspects.forEach { aspect -> it.add(aspect) }
+        })
+        json.addProperty("pokemon", pokemon.toString())
+    }
+
+    override fun fromJson(json: JsonObject) {
+        aspects.clear()
+        json.getAsJsonArray("aspects").forEach { element ->
+            aspects.add(element.asString)
+        }
+        pokemon = json.get("pokemon").asString.asIdentifierDefaultingNamespace()
+    }
+
+    override fun matches(player: ServerPlayerEntity, context: MutableMap<Identifier, MutableSet<String>>): Boolean {
+        val caughtAspects = context.getOrDefault(pokemon, mutableSetOf())
+        return this.aspects.all { it in caughtAspects }
+    }
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/BattleCountableCriterion.kt

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.advancement.criterion
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.util.toJsonArray
+import com.google.gson.JsonObject
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+open class BattleCountableCriterionTrigger(identifier: Identifier, criterionClass: Class<BattleCountableCriterionCondition>) : SimpleCriterionTrigger<BattleCountableContext, BattleCountableCriterionCondition>(identifier, criterionClass) {
+
+}
+
+class BattleCountableCriterionCondition(id: Identifier, predicate: LootContextPredicate) : CountableCriterionCondition<BattleCountableContext>(id, predicate) {
+
+    private var battleTypes = mutableListOf("any")
+
+    override fun fromJson(json: JsonObject) {
+        super.fromJson(json)
+        if(!json.get("battle_types").isJsonNull) {
+            battleTypes.clear()
+            json.get("battle_types").asJsonArray.asList().forEach() {
+                battleTypes.add(it.asString)
+            }
+        }
+    }
+
+    override fun toJson(json: JsonObject) {
+        super.toJson(json)
+        json.add("battle_types", battleTypes.toJsonArray())
+    }
+
+    override fun matches(player: ServerPlayerEntity, context: BattleCountableContext): Boolean {
+        var typeCheck = false
+        val advancementData = Cobblemon.playerData.get(player).advancementData
+        if (battleTypes.isEmpty() || battleTypes.contains("any")) {
+            typeCheck = true
+        }
+        if (battleTypes.contains("pvp")) {
+            typeCheck = context.battle.isPvP
+            context.times = advancementData.totalPvPBattleVictoryCount
+        }
+        if (battleTypes.contains("pvw")) {
+            typeCheck = context.battle.isPvW
+            context.times = advancementData.totalPvWBattleVictoryCount
+        }
+        if (battleTypes.contains("pvn")) {
+            typeCheck = context.battle.isPvN
+            context.times = advancementData.totalPvWBattleVictoryCount
+        }
+        if (battleTypes.size > 1) {
+            context.times = advancementData.totalBattleVictoryCount
+        }
+        return context.times >= count && typeCheck
+    }
+}
+
+open class BattleCountableContext(times : Int, var battle : PokemonBattle) : CountableContext(times)

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/CastPokeRodCriterionCondition.kt

@@ -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.advancement.criterion
+
+import com.google.gson.JsonObject
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+class CastPokeRodCriterionCondition(id: Identifier, predicate: LootContextPredicate): SimpleCriterionCondition<Boolean>(id, predicate) {
+    var hasBait: Boolean = false
+
+    override fun toJson(json: JsonObject) {
+        json.addProperty("hasBait", hasBait)
+    }
+
+    override fun fromJson(json: JsonObject) {
+        hasBait = json.get("hasBait").asBoolean
+    }
+
+    override fun matches(player: ServerPlayerEntity, context: Boolean): Boolean {
+        return hasBait == context
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/CatchPokemonCriterion.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.advancement.criterion
+
+import com.google.gson.JsonObject
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+/**
+ * A context that is used when you require a [CountableContext] along with some type string.
+ *
+ * @author Hiroku
+ * @since November 4th, 2022
+ */
+open class CountablePokemonTypeContext(times: Int, var type: String) : CountableContext(times)
+
+class CaughtPokemonCriterionCondition(id: Identifier, predicate: LootContextPredicate) : CountableCriterionCondition<CountablePokemonTypeContext>(id, predicate) {
+    var type = "any"
+    override fun toJson(json: JsonObject) {
+        super.toJson(json)
+        json.addProperty("type", type)
+    }
+
+    override fun fromJson(json: JsonObject) {
+        super.fromJson(json)
+        type = json.get("type")?.asString ?: "any"
+    }
+
+    override fun matches(player: ServerPlayerEntity, context: CountablePokemonTypeContext): Boolean {
+        return super.matches(player, context) && (context.type == type || type == "any")
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/CountableCriterion.kt

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.advancement.criterion
+
+import com.google.gson.JsonObject
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+/**
+ * A type of advancement criterion condition that requires some number of completions. This can be extended to add
+ * more conditions than just the count.
+ *
+ * @author Hiroku
+ * @since November 4th, 2022
+ */
+abstract class CountableCriterionCondition<T : CountableContext>(id: Identifier, predicate: LootContextPredicate) : SimpleCriterionCondition<T>(id, predicate) {
+    var count = 0
+    override fun fromJson(json: JsonObject) {
+        count = json.get("count")?.asInt ?: 0
+    }
+
+    override fun toJson(json: JsonObject) {
+        json.addProperty("count", count)
+    }
+
+    override fun matches(player: ServerPlayerEntity, context: T) = context.times >= count
+}
+
+/**
+ * A concrete subclass of [CountableCriterionCondition] so that you can have advancements that really just need the
+ * count and nothing else.
+ *
+ * This is just a quirk of using generics like this, don't worry about it. The criterion conditions that get used must
+ * not be generic typed.
+ *
+ * @author Hiroku
+ * @since November 4th, 2022
+ */
+class SimpleCountableCriterionCondition(id: Identifier, predicate: LootContextPredicate) : CountableCriterionCondition<CountableContext>(id, predicate)
+fun SimpleCriterionTrigger<CountableContext, SimpleCountableCriterionCondition>.trigger(player: ServerPlayerEntity, times: Int) = trigger(player, CountableContext(times))
+
+/**
+ * Some type of context that has a count associated with it, representing how many times the trigger has occurred.
+ *
+ * @author Hiroku
+ * @since November 4th, 2022
+ */
+open class CountableContext(var times: Int)

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/EvolvePokemonCriterionCondition.kt

@@ -0,0 +1,38 @@
+/*
+ * 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.advancement.criterion
+
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.google.gson.JsonObject
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+class EvolvePokemonCriterionCondition(id: Identifier, entity: LootContextPredicate) : CountableCriterionCondition<EvolvePokemonContext>(id, entity) {
+    var species = "any"
+    var evolution = "any"
+    override fun toJson(json: JsonObject) {
+        super.toJson(json)
+        json.addProperty("species", species)
+        json.addProperty("evolution", evolution)
+    }
+
+    override fun fromJson(json: JsonObject) {
+        super.fromJson(json)
+        species = json.get("species")?.asString ?: "any"
+        evolution = json.get("evolution")?.asString ?: "any"
+    }
+
+    override fun matches(player: ServerPlayerEntity, context: EvolvePokemonContext): Boolean {
+        return context.times >= count && (context.species == species.asIdentifierDefaultingNamespace() || species == "any") &&
+                (context.evolution == evolution.asIdentifierDefaultingNamespace() || evolution == "any")
+    }
+}
+
+open class EvolvePokemonContext(val species : Identifier, val evolution : Identifier, times: Int) : CountableContext(times)

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/LevelUpCriterion.kt

@@ -0,0 +1,41 @@
+/*
+ * 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.advancement.criterion
+
+import com.cobblemon.mod.common.pokemon.Pokemon
+import com.google.gson.JsonObject
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+class LevelUpCriterionCondition(id: Identifier, entity: LootContextPredicate) : SimpleCriterionCondition<LevelUpContext>(id, entity) {
+    var level = 0
+    var evolved = true
+    override fun toJson(json: JsonObject) {
+        json.addProperty("level", level)
+        json.addProperty("has_evolved", evolved)
+    }
+
+    override fun fromJson(json: JsonObject) {
+        level = json.get("level")?.asInt ?: 0
+        evolved = json.get("has_evolved")?.asBoolean ?: true
+    }
+
+    override fun matches(player: ServerPlayerEntity, context: LevelUpContext): Boolean {
+        val preEvo = context.pokemon.preEvolution == null
+        val hasEvolution = !context.pokemon.evolutions.none()
+        var evolutionCheck = true
+        if (preEvo || hasEvolution) {
+            evolutionCheck = !(preEvo == hasEvolution)
+        }
+        return level == context.level && evolutionCheck == evolved
+    }
+}
+
+open class LevelUpContext(var level : Int, var pokemon : Pokemon)

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/PartyCheckCriterion.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.advancement.criterion
+
+import com.cobblemon.mod.common.api.storage.party.PlayerPartyStore
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.cobblemon.mod.common.util.party
+import com.google.gson.JsonArray
+import com.google.gson.JsonObject
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+class PartyCheckCriterion(id: Identifier, entity: LootContextPredicate) : SimpleCriterionCondition<PartyCheckContext>(id, entity){
+    val party = mutableListOf<Identifier>()
+    override fun toJson(json: JsonObject) {
+        json.add("party", JsonArray(party.size).also {
+            party.forEach { pokemon -> it.add(pokemon.toString()) }
+        })
+    }
+
+    override fun fromJson(json: JsonObject) {
+        party.clear()
+        json.getAsJsonArray("party").forEach { element ->
+            party.add(element.asString.asIdentifierDefaultingNamespace())
+        }
+    }
+
+    override fun matches(player: ServerPlayerEntity, context: PartyCheckContext): Boolean {
+        val playerParty = player.party()
+        val matches = mutableListOf<Identifier>()
+        party.forEach {
+            if (it == "any".asIdentifierDefaultingNamespace()) {
+                matches.add(it)
+            }
+        }
+        val partyCount = playerParty.count()
+        if (matches.containsAll(party) && party.size == partyCount && matches.size == partyCount) return true
+        playerParty.iterator().forEach {
+            if (party.contains(it.species.resourceIdentifier)) {
+                matches.add(it.species.resourceIdentifier)
+            }
+        }
+        return matches.containsAll(party) && matches.size == partyCount
+    }
+}
+
+open class PartyCheckContext(val party : PlayerPartyStore)

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/PickStarterCriterionCondition.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.advancement.criterion
+
+import com.cobblemon.mod.common.api.pokemon.PokemonProperties
+import com.cobblemon.mod.common.pokemon.Pokemon
+import com.google.gson.JsonObject
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+/**
+ * A criteria that is triggered when a player picks a starter.
+ *
+ * @author Licious, Hiroku
+ * @since October 26th, 2022
+ */
+class PickStarterCriterionCondition(id: Identifier, predicate: LootContextPredicate) : SimpleCriterionCondition<Pokemon>(id, predicate) {
+    var properties = PokemonProperties()
+    override fun toJson(json: JsonObject) {
+        json.addProperty("properties", properties.originalString)
+    }
+
+    override fun fromJson(json: JsonObject) {
+        properties = PokemonProperties.parse(json.get("properties")?.asString ?: "")
+    }
+
+    override fun matches(player: ServerPlayerEntity, context: Pokemon) = properties.matches(context)
+}

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/PlantTumblestoneCriterionCondition.kt

@@ -0,0 +1,52 @@
+/*
+ * 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.advancement.criterion
+
+import com.cobblemon.mod.common.block.TumblestoneBlock
+import com.google.gson.JsonObject
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+import net.minecraft.util.math.BlockPos
+
+/**
+ * A criterion condition for when a tumblestone block is planted
+ * @param id The identifier of the criterion
+ * @param predicate The predicate for the criterion
+ *
+ * @author Aethen
+ * @since 02/28/2024
+ */
+class PlantTumblestoneCriterionCondition(id: Identifier, predicate: LootContextPredicate) :
+    SimpleCriterionCondition<PlantTumblestoneContext>(id, predicate) {
+    override fun toJson(json: JsonObject) {
+        // Add properties to json if needed. None needed for this criterion
+    }
+
+    override fun fromJson(json: JsonObject) {
+        // Parse properties from json if needed. None needed for this criterion
+    }
+
+    /**
+     * Checks if the tumblestone block can grow at the given position
+     * @param player The player that planted the tumblestone block
+     * @param context The context of the criterion
+     * @return True if the tumblestone block can grow at the given position, false otherwise
+     */
+    override fun matches(player: ServerPlayerEntity, context: PlantTumblestoneContext): Boolean {
+        return context.tumbleStoneBlock.canGrow(context.pos, player.world)
+    }
+}
+
+/**
+ * The context of the [PlantTumblestoneCriterionCondition]
+ * @param pos The position of the tumblestone block
+ * @param tumbleStoneBlock The tumblestone block
+ */
+open class PlantTumblestoneContext(var pos: BlockPos, var tumbleStoneBlock: TumblestoneBlock)

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/PokemonInteractCriterion.kt

@@ -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.advancement.criterion
+
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.google.gson.JsonObject
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+open class PokemonInteractContext(var type: Identifier, var item : Identifier)
+class PokemonInteractCriterion(id: Identifier, entity: LootContextPredicate) : SimpleCriterionCondition<PokemonInteractContext>(id, entity) {
+    var type = "any"
+    var item = "any"
+    override fun toJson(json: JsonObject) {
+        json.addProperty("type", type)
+        json.addProperty("item", item)
+    }
+
+    override fun fromJson(json: JsonObject) {
+        type = json.get("type")?.asString ?: "any"
+        item = json.get("item")?.asString ?: "any"
+    }
+
+    override fun matches(player: ServerPlayerEntity, context: PokemonInteractContext): Boolean {
+        return (context.type == type.asIdentifierDefaultingNamespace() || type == "any") && (context.item == item.asIdentifierDefaultingNamespace() || item == "any")
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/SimpleCriterion.kt

@@ -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.advancement.criterion
+
+import com.google.gson.JsonObject
+import net.minecraft.advancement.criterion.AbstractCriterion
+import net.minecraft.advancement.criterion.AbstractCriterionConditions
+import net.minecraft.predicate.entity.AdvancementEntityPredicateDeserializer
+import net.minecraft.predicate.entity.AdvancementEntityPredicateSerializer
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+/**
+ * A wrapping around the AbstractCriterion system of Minecraft. This allows the same base class to be used
+ * for all advancements by wrapping the advancement-specific contextual data in the generic T, the instance of
+ * the advancement conditions in the generic C, and allowing the condition to do all serialization, deserialization,
+ * and matching of context against conditions.
+ *
+ * @author Hiroku
+ * @since November 4th, 2022
+ */
+open class SimpleCriterionTrigger<T, C : SimpleCriterionCondition<T>>(
+    val _id: Identifier,
+    val criterionClass: Class<C>
+) : AbstractCriterion<C>() {
+    override fun getId() = _id
+    override fun conditionsFromJson(
+        obj: JsonObject,
+        playerPredicate: LootContextPredicate,
+        predicateDeserializer: AdvancementEntityPredicateDeserializer
+    ): C {
+        val instance = criterionClass.getConstructor(Identifier::class.java, LootContextPredicate::class.java).newInstance(id, playerPredicate)
+        instance.fromJson(obj)
+        return instance
+    }
+
+    fun trigger(player: ServerPlayerEntity, context: T) = this.trigger(player) { it.matches(player, context) }
+}
+
+/**
+ * The base of the conditions for Cobblemon's wrapping around Minecraft advancements. This is parameterized by whatever
+ * contextual information this condition needs to be checked, and must handle serialization and deserialization from JSON.
+ *
+ * @author Hiroku
+ * @since November 4th, 2022
+ */
+abstract class SimpleCriterionCondition<T>(
+    id: Identifier,
+    playerPredicate: LootContextPredicate
+): AbstractCriterionConditions(id, playerPredicate) {
+    override fun toJson(predicateSerializer: AdvancementEntityPredicateSerializer): JsonObject {
+        val json = super.toJson(predicateSerializer)
+        toJson(json)
+        return json
+    }
+
+    abstract fun toJson(json: JsonObject)
+    abstract fun fromJson(json: JsonObject)
+
+    abstract fun matches(player: ServerPlayerEntity, context: T): Boolean
+}

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/TradePokemonCriterionCondition.kt

@@ -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.advancement.criterion
+
+import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.google.gson.JsonObject
+import net.minecraft.predicate.entity.LootContextPredicate
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.util.Identifier
+
+class TradePokemonCriterionCondition(id: Identifier, entity: LootContextPredicate) : SimpleCriterionCondition<TradePokemonContext>(id, entity) {
+    var traded = "any"
+    var received = "any"
+    var tradedHeldItem = "any"
+    var receivedHeldItem = "any"
+    override fun toJson(json: JsonObject) {
+        json.addProperty("traded", traded)
+        json.addProperty("received", received)
+        json.addProperty("traded_held_item", tradedHeldItem)
+        json.addProperty("received_held_item", receivedHeldItem)
+    }
+
+    override fun fromJson(json: JsonObject) {
+        traded = json.get("traded")?.asString ?: "any"
+        received = json.get("received")?.asString ?: "any"
+        tradedHeldItem = json.get("traded_held_item")?.asString ?: "minecraft:air"
+        receivedHeldItem = json.get("received_held_item")?.asString ?: "minecraft:air"
+    }
+
+    override fun matches(player: ServerPlayerEntity, context: TradePokemonContext): Boolean {
+        val heldItem1 = context.traded.heldItem().item.registryEntry.registryKey().value
+        val heldItem2 = context.received.heldItem().item.registryEntry.registryKey().value
+        return (context.traded.species.resourceIdentifier == traded.asIdentifierDefaultingNamespace() || traded == "any") &&
+                (context.received.species.resourceIdentifier == received.asIdentifierDefaultingNamespace() || received == "any") &&
+                (heldItem1 == tradedHeldItem.asIdentifierDefaultingNamespace() || heldItem1 == "minecraft:air".asIdentifierDefaultingNamespace()) &&
+                (heldItem2 == receivedHeldItem.asIdentifierDefaultingNamespace() || heldItem2 == "minecraft:air".asIdentifierDefaultingNamespace())
+    }
+}
+
+open class TradePokemonContext(val traded: Pokemon, val received: Pokemon)

common/src/main/kotlin/com/cobblemon/mod/common/api/LevelCurve.kt

@@ -0,0 +1,58 @@
+/*
+ * 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.api
+
+/**
+ * A curve of experience that maps to levels. This is generally a discretized polynomial equation
+ * that takes a level as x and returns the amount of experience required to reach it as y.
+ *
+ * Some curves are too complicated to invert. Implementations can use [CachedLevelThresholds] to
+ * workaround this issue.
+ *
+ * @author Hiroku
+ * @since March 21st, 2022
+ */
+interface LevelCurve {
+    fun getExperience(level: Int): Int
+    fun getLevel(experience: Int): Int
+}
+
+/**
+ * A collection of thresholds for what levels require in terms of
+ * experience. This is a caching mechanism so that a complicated
+ * experience-to-level polynomial can be inverted.
+ *
+ * @author Hiroku
+ * @since March 21st, 2022
+ */
+class CachedLevelThresholds(
+    val levelLimit: Int = 1000,
+    val experienceToLevel: (Int) -> Int
+) {
+    val savedThresholds = mutableListOf<Int>()
+    fun getLevel(experience: Int): Int {
+        var level = 1
+        while (level <= savedThresholds.size) {
+            val threshold = savedThresholds[level - 1]
+            if (experience < threshold) {
+                return level - 1
+            }
+            level++
+        }
+        while (level < levelLimit) {
+            val threshold = experienceToLevel(level)
+            savedThresholds.add(threshold)
+            if (experience < threshold) {
+                return level - 1
+            }
+            level++
+        }
+        return 1
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ModDependant.kt

@@ -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.api
+
+import com.cobblemon.mod.common.Cobblemon
+
+/**
+ * Something that depends on some installed mod conditions.
+ *
+ * @author Hiroku
+ * @since July 8th, 2022
+ */
+interface ModDependant {
+    var neededInstalledMods: List<String>
+    var neededUninstalledMods: List<String>
+
+    fun isModDependencySatisfied(): Boolean {
+        return if (neededInstalledMods.isNotEmpty() && neededInstalledMods.any { !Cobblemon.implementation.isModInstalled(it) }) {
+            false
+        } else if (neededUninstalledMods.isNotEmpty() && neededUninstalledMods.any { Cobblemon.implementation.isModInstalled(it) }) {
+            false
+        } else {
+            true
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/PrioritizedList.kt

@@ -0,0 +1,59 @@
+/*
+ * 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.api
+
+/**
+ * Functions like a list which is ordered by [Priority]. Within each category of priority,
+ * order is first-come-first-served. Having the same value in multiple priorities is possible
+ * but can cause stickiness.
+ *
+ * @author Hiroku
+ * @since February 18th, 2022
+ */
+open class PrioritizedList<T> : Iterable<T> {
+    protected val priorityMap = mutableMapOf<Priority, MutableList<T>>()
+    // Please don't change arraylist, we need insertion order
+    protected val ordered = arrayListOf<T>()
+
+    val mapping: Map<Priority, List<T>>
+        get() = priorityMap.toMap()
+
+    private fun reorder() {
+        ordered.clear()
+        Priority.values().forEach {
+            priorityMap[it]?.let { ordered.addAll(it) }
+        }
+    }
+
+    fun add(priority: Priority, value: T) {
+        // Please don't change arraylist, we need insertion order
+        priorityMap.putIfAbsent(priority, arrayListOf())
+        priorityMap[priority]?.add(value)
+        reorder()
+    }
+
+    fun remove(value: T) {
+        priorityMap.values.forEach { it.remove(value) }
+        reorder()
+    }
+
+    fun remove(priority: Priority, value: T) {
+        priorityMap[priority]?.remove(value)
+        reorder()
+    }
+
+    fun clear() {
+        priorityMap.clear()
+        ordered.clear()
+    }
+
+    fun isEmpty() = ordered.isEmpty()
+
+    override fun iterator() = ordered.iterator()
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/Priority.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api
+
+enum class Priority {
+    HIGHEST,
+    HIGH,
+    NORMAL,
+    LOW,
+    LOWEST
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/SeasonResolver.kt

@@ -0,0 +1,24 @@
+/*
+ * 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.api
+
+import com.cobblemon.mod.common.pokemon.feature.CobblemonSeason
+import net.minecraft.util.math.BlockPos
+import net.minecraft.world.WorldAccess
+
+/**
+ * Figures out what season it is at a particular position. Season is just a general approximation
+ * used for things like Deerling variations.
+ *
+ * @author Hiroku
+ * @since November 25th, 2022
+ */
+fun interface SeasonResolver {
+    operator fun invoke(world: WorldAccess, pos: BlockPos): CobblemonSeason?
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/abilities/Abilities.kt

@@ -0,0 +1,70 @@
+/*
+ * 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.api.abilities
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.data.DataRegistry
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.battles.runner.ShowdownService
+import com.cobblemon.mod.common.net.messages.client.data.AbilityRegistrySyncPacket
+import com.cobblemon.mod.common.pokemon.abilities.HiddenAbilityType
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.resource.ResourceManager
+import net.minecraft.resource.ResourceType
+import net.minecraft.server.network.ServerPlayerEntity
+
+/**
+ * Registry for all known Abilities
+ */
+object Abilities : DataRegistry {
+
+    override val id = cobblemonResource("abilities")
+    override val type = ResourceType.SERVER_DATA
+    override val observable = SimpleObservable<Abilities>()
+
+    val DUMMY = AbilityTemplate(name = "dummy")
+
+    private val abilityMap = mutableMapOf<String, AbilityTemplate>()
+
+    override fun reload(manager: ResourceManager) {
+        PotentialAbility.types.clear()
+        PotentialAbility.types.add(CommonAbilityType)
+        PotentialAbility.types.add(HiddenAbilityType)
+        this.abilityMap.clear()
+        val abilitiesJson = ShowdownService.service.getAbilityIds()
+        for (i in 0 until abilitiesJson.size()) {
+            val id = abilitiesJson[i].asString
+            val ability = AbilityTemplate(id)
+            this.register(ability)
+        }
+        Cobblemon.LOGGER.info("Loaded {} abilities", this.abilityMap.size)
+        this.observable.emit(this)
+    }
+
+    override fun sync(player: ServerPlayerEntity) {
+        AbilityRegistrySyncPacket(all()).sendToPlayer(player)
+    }
+
+    fun register(ability: AbilityTemplate): AbilityTemplate {
+        this.abilityMap[ability.name.lowercase()] = ability
+        return ability
+    }
+
+    fun all() = this.abilityMap.values.toList()
+    fun first() = this.abilityMap.values.first()
+    fun get(name: String) = abilityMap[name.lowercase()]
+    fun getOrException(name: String) = get(name) ?: throw IllegalArgumentException("Unable to find ability of name: $name")
+    fun count() = this.abilityMap.size
+
+    internal fun receiveSyncPacket(abilities: Collection<AbilityTemplate>) {
+        this.abilityMap.clear()
+        abilities.forEach { ability -> this.register(ability) }
+    }
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/abilities/Ability.kt

@@ -0,0 +1,95 @@
+/*
+ * 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.api.abilities
+
+import com.cobblemon.mod.common.api.Priority
+import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.util.DataKeys
+import com.google.gson.JsonObject
+import net.minecraft.nbt.NbtCompound
+
+/**
+ * Representing an Ability with all its attributes
+ *
+ * Can be extended to allow for custom attributes (be sure to overwrite the load and save methods)
+ *
+ * @author Qu
+ * @since January 9th, 2022
+ */
+open class Ability internal constructor(var template: AbilityTemplate, forced: Boolean) {
+
+    val name: String
+        get() = template.name
+
+    val displayName: String
+        get() = template.displayName
+
+    val description: String
+        get() = template.description
+
+    /**
+     * This represents the last known index of this backing ability in the species data.
+     * @see [Pokemon.updateAbility].
+     */
+    var forced: Boolean = forced
+        internal set
+
+    /**
+     * This represents the last known index of this backing ability in the species data.
+     *
+     * @see [Pokemon.updateAbility].
+     */
+    var index: Int = -1
+        internal set
+
+    /**
+     * The last known priority of this ability in the species data.
+     *
+     * @see [Pokemon.updateAbility].
+     */
+    var priority = Priority.LOWEST
+        internal set
+
+    open fun saveToNBT(nbt: NbtCompound): NbtCompound {
+        nbt.putString(DataKeys.POKEMON_ABILITY_NAME, name)
+        nbt.putBoolean(DataKeys.POKEMON_ABILITY_FORCED, forced)
+        nbt.putInt(DataKeys.POKEMON_ABILITY_INDEX, index)
+        nbt.putString(DataKeys.POKEMON_ABILITY_PRIORITY, priority.name)
+        return nbt
+    }
+
+    open fun saveToJSON(json: JsonObject): JsonObject {
+        json.addProperty(DataKeys.POKEMON_ABILITY_NAME, name)
+        json.addProperty(DataKeys.POKEMON_ABILITY_FORCED, forced)
+        json.addProperty(DataKeys.POKEMON_ABILITY_INDEX, index)
+        json.addProperty(DataKeys.POKEMON_ABILITY_PRIORITY, priority.name)
+        return json
+    }
+
+    open fun loadFromNBT(nbt: NbtCompound): Ability {
+        this.template = Abilities.getOrException(nbt.getString(DataKeys.POKEMON_ABILITY_NAME))
+        this.forced = nbt.getBoolean(DataKeys.POKEMON_ABILITY_FORCED)
+        if (nbt.contains(DataKeys.POKEMON_ABILITY_INDEX) && nbt.contains(DataKeys.POKEMON_ABILITY_PRIORITY)) {
+            this.index = nbt.getInt(DataKeys.POKEMON_ABILITY_INDEX)
+            this.priority = Priority.valueOf(nbt.getString(DataKeys.POKEMON_ABILITY_PRIORITY))
+        }
+        return this
+    }
+
+    open fun loadFromJSON(json: JsonObject): Ability {
+        this.template = Abilities.getOrException(json.get(DataKeys.POKEMON_ABILITY_NAME).asString)
+        this.forced = json.get(DataKeys.POKEMON_ABILITY_FORCED)?.asBoolean ?: false
+        if (json.has(DataKeys.POKEMON_ABILITY_INDEX) && json.has(DataKeys.POKEMON_ABILITY_PRIORITY)) {
+            this.index = json.get(DataKeys.POKEMON_ABILITY_INDEX).asInt
+            this.priority = Priority.valueOf(json.get(DataKeys.POKEMON_ABILITY_PRIORITY).asString)
+        }
+        return this
+    }
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/abilities/AbilityPool.kt

@@ -0,0 +1,38 @@
+/*
+ * 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.api.abilities
+
+import com.cobblemon.mod.common.Cobblemon.LOGGER
+import com.cobblemon.mod.common.api.PrioritizedList
+import com.cobblemon.mod.common.api.Priority
+import com.cobblemon.mod.common.pokemon.Species
+
+/**
+ * A pool of potential abilities, as a [PrioritizedList]. The added logic of this subclass
+ * is that it has selection logic. Given a species and a set of aspects, it will go through
+ * each priority group, and if it can then it will pick from that group and return it.
+ *
+ * @author Hiroku
+ * @since July 28th, 2022
+ */
+open class AbilityPool : PrioritizedList<PotentialAbility>() {
+    fun select(species: Species, aspects: Set<String>): Pair<Ability, Priority> {
+        for (priority in Priority.values()) {
+            val potentialAbilities = priorityMap[priority]?.filter { it.isSatisfiedBy(aspects) } ?: continue
+            if (potentialAbilities.isNotEmpty()) {
+                return potentialAbilities.random().template.create() to priority
+            }
+        }
+
+        LOGGER.error("Unable to select an ability from the pool for $species and aspects: ${aspects.joinToString()}")
+        LOGGER.error("Usually this happens when a client is doing logic it shouldn't. Please show this to the Cobblemon developers!")
+        Exception().printStackTrace()
+        return Abilities.first().create() to Priority.LOWEST
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/abilities/AbilityTemplate.kt

@@ -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.api.abilities
+
+import com.google.gson.JsonObject
+import net.minecraft.nbt.NbtCompound
+
+/**
+ * This represents the base of an Ability.
+ * To build an Ability you MUST use its template.
+ *
+ * @param name: The English name used to load / find it (spaces -> _)
+ */
+class AbilityTemplate(
+    val name: String = "",
+    var builder: (AbilityTemplate, forced: Boolean) -> Ability = { template, forced -> Ability(template, forced) },
+    val displayName: String = "cobblemon.ability.$name",
+    val description: String = "cobblemon.ability.$name.desc"
+) {
+    /**
+     * Returns the Ability or if applicable the extension connected to this template
+     */
+    fun create(forced: Boolean = false) = builder(this, forced)
+
+    /**
+     * Returns the Ability and loads the given NBT Tag into it.
+     *
+     * Ability extensions need to write and read their needed data from here.
+     */
+    fun create(nbt: NbtCompound) = create().loadFromNBT(nbt)
+
+    /**
+     * Returns the Ability and loads the given JSON object into it.
+     *
+     * Ability extensions need to write and read their needed data from here.
+     */
+    fun create(json: JsonObject) = create().loadFromJSON(json)
+
+}