When you wish upon a star

Makes no difference who you are
Anything your heart desires
Will come to you
If your heart is in your dream
No request is too extreme
When you wish upon a star
As dreamers do
Fate is kind
She brings to those who love
The sweet fulfillment of
Their secret longing
Like a bolt out of the blue
Fate steps in and sees you through
When you wish upon a star
Your dreams come true

.gitignore

@@ -5,7 +5,8 @@ bin
 .metadata
 .classpath
 .project
-
+/.architectury-transformer/
+common/src/main/resources/assets/cobblemon/showdown
 # idea
 out
 *.ipr
@@ -23,6 +24,13 @@ run
 
 # 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/

.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-logic/build.gradle.kts

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

build-logic/settings.gradle.kts

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

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

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

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

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

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

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

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

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

build-logic/src/main/kotlin/constants.kt

@@ -0,0 +1,2 @@
+
+const val ACCESS_WIDENER = "src/main/resources/cobblemon-common.accesswidener"

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

changelog.txt

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

common/build.gradle.kts

@@ -0,0 +1,61 @@
+/*
+ *
+ *  * Copyright (C) 2023 Cobblemon Contributors
+ *  *
+ *  * This Source Code Form is subject to the terms of the Mozilla Public
+ *  * License, v. 2.0. If a copy of the MPL was not distributed with this
+ *  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ */
+
+plugins {
+    id("cobblemon.base-conventions")
+    id("cobblemon.publish-conventions")
+}
+
+architectury {
+    common("forge", "fabric")
+}
+
+repositories {
+    maven(url = "${rootProject.projectDir}/deps")
+    maven(url = "https://api.modrinth.com/maven")
+    mavenLocal()
+}
+
+dependencies {
+    implementation(libs.stdlib)
+    implementation(libs.reflect)
+
+    modImplementation(libs.fabricLoader)
+    //Flywheel has no common dep so just pick one and don't use any platform specific code in common
+//    modCompileOnly(libs.flywheelFabric)
+    modApi(libs.molang)
+    compileOnlyApi(libs.jeiApi)
+    modCompileOnly(libs.adornFabric)
+    modCompileOnly(libs.lambDynamicLights) { isTransitive = false }
+
+    // For Showdown
+    modCompileOnly(libs.graal)
+
+    //shadowCommon group: 'commons-io', name: 'commons-io', version: '2.6'
+
+    // For datastore
+    modCompileOnly(libs.mongoDriverCore)
+    modCompileOnly(libs.mongoDriverSync)
+
+    testRuntimeOnly(libs.junitEngine)
+    testImplementation(libs.junitApi)
+    testImplementation(libs.junitParams)
+    testImplementation(libs.mockito)
+    testImplementation(libs.mockk)
+    testImplementation(libs.classgraph)
+}
+
+tasks.withType<Test> {
+    useJUnitPlatform()
+    testLogging {
+        setEvents(listOf("failed"))
+        setExceptionFormat("full")
+    }
+}

common/gradle.properties

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

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/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/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/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/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,499 @@
+/*
+ * 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.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.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.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.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.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.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.HiddenAbilityPropertyType
+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 java.io.File
+import java.io.FileReader
+import java.io.FileWriter
+import java.io.PrintWriter
+import java.util.UUID
+import kotlin.properties.Delegates
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.jvm.isAccessible
+import kotlin.reflect.jvm.javaField
+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
+
+object Cobblemon {
+    const val MODID = "cobblemon"
+    const val VERSION = "1.4.0"
+    const val CONFIG_PATH = "config/$MODID/main.json"
+    val 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
+        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))
+                    }
+            }
+        }
+
+        PlatformEvents.CHANGE_DIMENSION.subscribe {
+            it.player.party().forEach { pokemon -> pokemon.entity?.recallWithAnimation() }
+        }
+
+        TrackedDataHandlerRegistry.register(Vec3DataSerializer)
+        TrackedDataHandlerRegistry.register(StringSetDataSerializer)
+        TrackedDataHandlerRegistry.register(PoseTypeDataSerializer)
+        TrackedDataHandlerRegistry.register(IdentifierDataSerializer)
+
+        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.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)
+
+        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,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
+
+import net.minecraft.entity.ai.brain.Activity
+
+object CobblemonActivities {
+    val activities = mutableListOf<Activity>()
+    val BATTLING_ACTIVITY = Activity("pokemon_battling")
+
+    fun register(activity: Activity): Activity {
+        activities.add(activity)
+        return activity
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonBlockEntities.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.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.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 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 DYNITE_ORE: BlockEntityType<DyniteOreBlockEntity> = this.create("dynite_ore",
+        BlockEntityType.Builder.create(::DyniteOreBlockEntity, CobblemonBlocks.DYNITE_ORE)
+            .build(null)
+    )
+}

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

@@ -0,0 +1,493 @@
+/*
+ * 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.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 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")
+
+    @JvmField
+    val DYNITE_ORE = this.create("dynite_ore", DyniteOreBlock(
+        AbstractBlock.Settings.create()
+            .mapColor(MapColor.BRIGHT_RED)
+            .strength(4.5f, 3f)
+            .requiresTool()
+            .sounds(BlockSoundGroup.METAL)
+    ))
+
+    // 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(BlockSoundGroup.CROP)))
+    @JvmField
+    val ENERGY_ROOT = this.create("energy_root", EnergyRootBlock(AbstractBlock.Settings.create().pistonBehavior(PistonBehavior.DESTROY).burnable().mapColor(MapColor.DIRT_BROWN).noCollision().ticksRandomly().breakInstantly().sounds(BlockSoundGroup.ROOTS)))
+    @JvmField
+    val BIG_ROOT = this.create("big_root", BigRootBlock(AbstractBlock.Settings.create().pistonBehavior(PistonBehavior.DESTROY).burnable().mapColor(MapColor.DARK_GREEN).noCollision().ticksRandomly().breakInstantly().sounds(BlockSoundGroup.ROOTS)))
+    @JvmField
+    val REVIVAL_HERB = this.create("revival_herb", RevivalHerbBlock(AbstractBlock.Settings.create().pistonBehavior(PistonBehavior.DESTROY).mapColor(MapColor.DARK_GREEN).burnable().noCollision().breakInstantly().sounds(BlockSoundGroup.CROP)))
+
+    @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)
+        .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)
+        .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)
+        .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 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.METAL)
+                .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 RED_MINT = create("red_mint", MintBlock(MintType.RED, AbstractBlock.Settings.create().mapColor(MapColor.RED).noCollision().ticksRandomly().breakInstantly().sounds(BlockSoundGroup.CROP)))
+    @JvmField
+    val BLUE_MINT = create("blue_mint", MintBlock(MintType.BLUE, AbstractBlock.Settings.create().mapColor(MapColor.BLUE).noCollision().ticksRandomly().breakInstantly().sounds(BlockSoundGroup.CROP)))
+    @JvmField
+    val CYAN_MINT = create("cyan_mint", MintBlock(MintType.CYAN, AbstractBlock.Settings.create().mapColor(MapColor.CYAN).noCollision().ticksRandomly().breakInstantly().sounds(BlockSoundGroup.CROP)))
+    @JvmField
+    val PINK_MINT = create("pink_mint", MintBlock(MintType.PINK, AbstractBlock.Settings.create().mapColor(MapColor.PINK).noCollision().ticksRandomly().breakInstantly().sounds(BlockSoundGroup.CROP)))
+    @JvmField
+    val GREEN_MINT = create("green_mint", MintBlock(MintType.GREEN, AbstractBlock.Settings.create().mapColor(MapColor.GREEN).noCollision().ticksRandomly().breakInstantly().sounds(BlockSoundGroup.CROP)))
+    @JvmField
+    val WHITE_MINT = create("white_mint", MintBlock(MintType.WHITE, AbstractBlock.Settings.create().mapColor(MapColor.WHITE).noCollision().ticksRandomly().breakInstantly().sounds(BlockSoundGroup.CROP)))
+
+    @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(BlockSoundGroup.CROP)))
+    @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(BlockSoundGroup.CROP).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,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
+
+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)
+    }
+}

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

@@ -0,0 +1,102 @@
+/*
+ * 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.fallingstar.FallingStarEntity
+import com.cobblemon.mod.common.entity.generic.GenericBedrockEntity
+import com.cobblemon.mod.common.entity.fishing.PokeRodFishingBobberEntity
+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 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 FALLING_STAR_ENTITY_KEY = cobblemonResource("falling_star")
+    @JvmField
+    val FALLING_STAR_ENTITY: EntityType<FallingStarEntity> = this.create(
+        FALLING_STAR_ENTITY_KEY.path,
+        EntityType.Builder.create({ _, world -> FallingStarEntity(world) }, SpawnGroup.MISC)
+            .build(FALLING_STAR_ENTITY_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())
+    )
+
+    fun registerAttributes(consumer: (EntityType<out LivingEntity>, DefaultAttributeContainer.Builder) -> Unit) {
+        consumer(POKEMON, PokemonEntity.createAttributes())
+    }
+
+}

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/CobblemonItems.kt

@@ -0,0 +1,939 @@
+/*
+ * 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.mulch.MulchVariant
+import com.cobblemon.mod.common.api.pokeball.PokeBalls
+import com.cobblemon.mod.common.api.pokemon.Natures
+import com.cobblemon.mod.common.api.pokemon.stats.Stats
+import com.cobblemon.mod.common.api.pokemon.status.Statuses
+import com.cobblemon.mod.common.block.BerryBlock
+import com.cobblemon.mod.common.block.MintBlock
+import com.cobblemon.mod.common.block.MintBlock.MintType
+import com.cobblemon.mod.common.entity.boat.CobblemonBoatType
+import com.cobblemon.mod.common.item.*
+import com.cobblemon.mod.common.item.armor.CobblemonArmorTrims
+import com.cobblemon.mod.common.item.battle.DireHitItem
+import com.cobblemon.mod.common.item.battle.GuardSpecItem
+import com.cobblemon.mod.common.item.battle.XStatItem
+import com.cobblemon.mod.common.item.berry.FriendshipRaisingBerryItem
+import com.cobblemon.mod.common.item.berry.HealingBerryItem
+import com.cobblemon.mod.common.item.berry.PPRestoringBerryItem
+import com.cobblemon.mod.common.item.berry.PortionHealingBerryItem
+import com.cobblemon.mod.common.item.berry.StatusCuringBerryItem
+import com.cobblemon.mod.common.item.berry.VolatileCuringBerryItem
+import com.cobblemon.mod.common.item.interactive.*
+import com.cobblemon.mod.common.item.interactive.PotionItem
+import com.cobblemon.mod.common.platform.PlatformRegistry
+import com.cobblemon.mod.common.pokeball.PokeBall
+import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.block.Block
+import net.minecraft.entity.LivingEntity
+import net.minecraft.entity.effect.StatusEffectInstance
+import net.minecraft.entity.effect.StatusEffects
+import net.minecraft.item.*
+import net.minecraft.item.BlockItem
+import net.minecraft.item.FoodComponent
+import net.minecraft.item.HangingSignItem
+import net.minecraft.item.Item
+import net.minecraft.item.ItemStack
+import net.minecraft.item.SignItem
+import net.minecraft.item.SmithingTemplateItem
+import net.minecraft.item.StewItem
+import net.minecraft.registry.Registries
+import net.minecraft.registry.Registry
+import net.minecraft.registry.RegistryKey
+import net.minecraft.registry.RegistryKeys
+import net.minecraft.util.Identifier
+import net.minecraft.world.World
+
+@Suppress("unused")
+object CobblemonItems : PlatformRegistry<Registry<Item>, RegistryKey<Registry<Item>>, Item>() {
+    override val registry: Registry<Item> = Registries.ITEM
+    override val registryKey: RegistryKey<Registry<Item>> = RegistryKeys.ITEM
+
+    @JvmField
+    val pokeBalls = mutableListOf<PokeBallItem>()
+    @JvmField
+    val POKE_BALL = pokeBallItem(PokeBalls.POKE_BALL)
+    @JvmField
+    val CITRINE_BALL = pokeBallItem(PokeBalls.CITRINE_BALL)
+    @JvmField
+    val VERDANT_BALL = pokeBallItem(PokeBalls.VERDANT_BALL)
+    @JvmField
+    val AZURE_BALL = pokeBallItem(PokeBalls.AZURE_BALL)
+    @JvmField
+    val ROSEATE_BALL = pokeBallItem(PokeBalls.ROSEATE_BALL)
+    @JvmField
+    val SLATE_BALL = pokeBallItem(PokeBalls.SLATE_BALL)
+    @JvmField
+    val PREMIER_BALL = pokeBallItem(PokeBalls.PREMIER_BALL)
+    @JvmField
+    val GREAT_BALL = pokeBallItem(PokeBalls.GREAT_BALL)
+    @JvmField
+    val ULTRA_BALL = pokeBallItem(PokeBalls.ULTRA_BALL)
+    @JvmField
+    val SAFARI_BALL = pokeBallItem(PokeBalls.SAFARI_BALL)
+    @JvmField
+    val FAST_BALL = pokeBallItem(PokeBalls.FAST_BALL)
+    @JvmField
+    val LEVEL_BALL = pokeBallItem(PokeBalls.LEVEL_BALL)
+    @JvmField
+    val LURE_BALL = pokeBallItem(PokeBalls.LURE_BALL)
+    @JvmField
+    val HEAVY_BALL = pokeBallItem(PokeBalls.HEAVY_BALL)
+    @JvmField
+    val LOVE_BALL = pokeBallItem(PokeBalls.LOVE_BALL)
+    @JvmField
+    val FRIEND_BALL = pokeBallItem(PokeBalls.FRIEND_BALL)
+    @JvmField
+    val MOON_BALL = pokeBallItem(PokeBalls.MOON_BALL)
+    @JvmField
+    val SPORT_BALL = pokeBallItem(PokeBalls.SPORT_BALL)
+    @JvmField
+    val PARK_BALL = pokeBallItem(PokeBalls.PARK_BALL)
+    @JvmField
+    val NET_BALL = pokeBallItem(PokeBalls.NET_BALL)
+    @JvmField
+    val DIVE_BALL = pokeBallItem(PokeBalls.DIVE_BALL)
+    @JvmField
+    val NEST_BALL = pokeBallItem(PokeBalls.NEST_BALL)
+    @JvmField
+    val REPEAT_BALL = pokeBallItem(PokeBalls.REPEAT_BALL)
+    @JvmField
+    val TIMER_BALL = pokeBallItem(PokeBalls.TIMER_BALL)
+    @JvmField
+    val LUXURY_BALL = pokeBallItem(PokeBalls.LUXURY_BALL)
+    @JvmField
+    val DUSK_BALL = pokeBallItem(PokeBalls.DUSK_BALL)
+    @JvmField
+    val HEAL_BALL = pokeBallItem(PokeBalls.HEAL_BALL)
+    @JvmField
+    val QUICK_BALL = pokeBallItem(PokeBalls.QUICK_BALL)
+    @JvmField
+    val DREAM_BALL = pokeBallItem(PokeBalls.DREAM_BALL)
+    @JvmField
+    val BEAST_BALL = pokeBallItem(PokeBalls.BEAST_BALL)
+    @JvmField
+    val MASTER_BALL = pokeBallItem(PokeBalls.MASTER_BALL)
+    @JvmField
+    val CHERISH_BALL = pokeBallItem(PokeBalls.CHERISH_BALL)
+    @JvmField
+    val ANCIENT_POKE_BALL = pokeBallItem(PokeBalls.ANCIENT_POKE_BALL)
+    @JvmField
+    val ANCIENT_CITRINE_BALL = pokeBallItem(PokeBalls.ANCIENT_CITRINE_BALL)
+    @JvmField
+    val ANCIENT_VERDANT_BALL = pokeBallItem(PokeBalls.ANCIENT_VERDANT_BALL)
+    @JvmField
+    val ANCIENT_AZURE_BALL = pokeBallItem(PokeBalls.ANCIENT_AZURE_BALL)
+    @JvmField
+    val ANCIENT_ROSEATE_BALL = pokeBallItem(PokeBalls.ANCIENT_ROSEATE_BALL)
+    @JvmField
+    val ANCIENT_SLATE_BALL = pokeBallItem(PokeBalls.ANCIENT_SLATE_BALL)
+    @JvmField
+    val ANCIENT_IVORY_BALL = pokeBallItem(PokeBalls.ANCIENT_IVORY_BALL)
+    @JvmField
+    val ANCIENT_GREAT_BALL = pokeBallItem(PokeBalls.ANCIENT_GREAT_BALL)
+    @JvmField
+    val ANCIENT_ULTRA_BALL = pokeBallItem(PokeBalls.ANCIENT_ULTRA_BALL)
+    @JvmField
+    val ANCIENT_FEATHER_BALL = pokeBallItem(PokeBalls.ANCIENT_FEATHER_BALL)
+    @JvmField
+    val ANCIENT_WING_BALL = pokeBallItem(PokeBalls.ANCIENT_WING_BALL)
+    @JvmField
+    val ANCIENT_JET_BALL = pokeBallItem(PokeBalls.ANCIENT_JET_BALL)
+    @JvmField
+    val ANCIENT_HEAVY_BALL = pokeBallItem(PokeBalls.ANCIENT_HEAVY_BALL)
+    @JvmField
+    val ANCIENT_LEADEN_BALL = pokeBallItem(PokeBalls.ANCIENT_LEADEN_BALL)
+    @JvmField
+    val ANCIENT_GIGATON_BALL = pokeBallItem(PokeBalls.ANCIENT_GIGATON_BALL)
+    @JvmField
+    val ANCIENT_ORIGIN_BALL = pokeBallItem(PokeBalls.ANCIENT_ORIGIN_BALL)
+
+    @JvmField
+    val VIVICHOKE = compostableItem("vivichoke")
+
+    @JvmField
+    val VIVICHOKE_SEEDS = compostableItem("vivichoke_seeds", VivichokeItem(CobblemonBlocks.VIVICHOKE_SEEDS))
+
+    @JvmField
+    val RED_APRICORN = apricornItem("red", ApricornItem(CobblemonBlocks.RED_APRICORN))
+    @JvmField
+    val YELLOW_APRICORN = apricornItem("yellow", ApricornItem(CobblemonBlocks.YELLOW_APRICORN))
+    @JvmField
+    val GREEN_APRICORN = apricornItem("green", ApricornItem(CobblemonBlocks.GREEN_APRICORN))
+    @JvmField
+    val BLUE_APRICORN = apricornItem("blue", ApricornItem(CobblemonBlocks.BLUE_APRICORN))
+    @JvmField
+    val PINK_APRICORN = apricornItem("pink", ApricornItem(CobblemonBlocks.PINK_APRICORN))
+    @JvmField
+    val BLACK_APRICORN = apricornItem("black", ApricornItem(CobblemonBlocks.BLACK_APRICORN))
+    @JvmField
+    val WHITE_APRICORN = apricornItem("white", ApricornItem(CobblemonBlocks.WHITE_APRICORN))
+
+    @JvmField
+    val RED_APRICORN_SEED = apricornSeedItem("red", ApricornSeedItem(CobblemonBlocks.RED_APRICORN_SAPLING, CobblemonBlocks.RED_APRICORN))
+    @JvmField
+    val YELLOW_APRICORN_SEED = apricornSeedItem("yellow", ApricornSeedItem(CobblemonBlocks.YELLOW_APRICORN_SAPLING, CobblemonBlocks.YELLOW_APRICORN))
+    @JvmField
+    val GREEN_APRICORN_SEED = apricornSeedItem("green", ApricornSeedItem(CobblemonBlocks.GREEN_APRICORN_SAPLING, CobblemonBlocks.GREEN_APRICORN))
+    @JvmField
+    val BLUE_APRICORN_SEED = apricornSeedItem("blue", ApricornSeedItem(CobblemonBlocks.BLUE_APRICORN_SAPLING, CobblemonBlocks.BLUE_APRICORN))
+    @JvmField
+    val PINK_APRICORN_SEED = apricornSeedItem("pink", ApricornSeedItem(CobblemonBlocks.PINK_APRICORN_SAPLING, CobblemonBlocks.PINK_APRICORN))
+    @JvmField
+    val BLACK_APRICORN_SEED = apricornSeedItem("black", ApricornSeedItem(CobblemonBlocks.BLACK_APRICORN_SAPLING, CobblemonBlocks.BLACK_APRICORN))
+    @JvmField
+    val WHITE_APRICORN_SEED = apricornSeedItem("white", ApricornSeedItem(CobblemonBlocks.WHITE_APRICORN_SAPLING, CobblemonBlocks.WHITE_APRICORN))
+
+    @JvmField
+    val APRICORN_LOG = blockItem("apricorn_log", CobblemonBlocks.APRICORN_LOG)
+    @JvmField
+    val STRIPPED_APRICORN_LOG = blockItem("stripped_apricorn_log", CobblemonBlocks.STRIPPED_APRICORN_LOG)
+    @JvmField
+    val APRICORN_WOOD = blockItem("apricorn_wood", CobblemonBlocks.APRICORN_WOOD)
+    @JvmField
+    val STRIPPED_APRICORN_WOOD = blockItem("stripped_apricorn_wood", CobblemonBlocks.STRIPPED_APRICORN_WOOD)
+    @JvmField
+    val APRICORN_PLANKS = blockItem("apricorn_planks", CobblemonBlocks.APRICORN_PLANKS)
+    @JvmField
+    val APRICORN_LEAVES = compostableBlockItem("apricorn_leaves", CobblemonBlocks.APRICORN_LEAVES)
+    @JvmField
+    val APRICORN_BOAT = create("apricorn_boat", CobblemonBoatItem(CobblemonBoatType.APRICORN, false, Item.Settings().maxCount(1)))
+    @JvmField
+    val APRICORN_CHEST_BOAT = create("apricorn_chest_boat", CobblemonBoatItem(CobblemonBoatType.APRICORN, true, Item.Settings().maxCount(1)))
+
+    @JvmField
+    val APRICORN_DOOR = blockItem("apricorn_door", CobblemonBlocks.APRICORN_DOOR)
+    @JvmField
+    val APRICORN_TRAPDOOR = blockItem("apricorn_trapdoor", CobblemonBlocks.APRICORN_TRAPDOOR)
+    @JvmField
+    val APRICORN_FENCE = blockItem("apricorn_fence", CobblemonBlocks.APRICORN_FENCE)
+    @JvmField
+    val APRICORN_FENCE_GATE = blockItem("apricorn_fence_gate", CobblemonBlocks.APRICORN_FENCE_GATE)
+    @JvmField
+    val APRICORN_BUTTON = blockItem("apricorn_button", CobblemonBlocks.APRICORN_BUTTON)
+    @JvmField
+    val APRICORN_PRESSURE_PLATE = blockItem("apricorn_pressure_plate", CobblemonBlocks.APRICORN_PRESSURE_PLATE)
+    @JvmField
+    val APRICORN_SLAB = blockItem("apricorn_slab", CobblemonBlocks.APRICORN_SLAB)
+    @JvmField
+    val APRICORN_STAIRS = blockItem("apricorn_stairs", CobblemonBlocks.APRICORN_STAIRS)
+    @JvmField
+    val APRICORN_SIGN = this.create("apricorn_sign", SignItem(Item.Settings().maxCount(16), CobblemonBlocks.APRICORN_SIGN, CobblemonBlocks.APRICORN_WALL_SIGN))
+    @JvmField
+    val APRICORN_HANGING_SIGN = this.create("apricorn_hanging_sign", HangingSignItem(CobblemonBlocks.APRICORN_HANGING_SIGN, CobblemonBlocks.APRICORN_WALL_HANGING_SIGN, Item.Settings().maxCount(16)))
+
+    @JvmField
+    val RESTORATION_TANK = blockItem("restoration_tank", CobblemonBlocks.RESTORATION_TANK)
+    @JvmField
+    val FOSSIL_ANALYZER = blockItem("fossil_analyzer", CobblemonBlocks.FOSSIL_ANALYZER)
+    @JvmField
+    val MONITOR = blockItem("monitor", CobblemonBlocks.MONITOR)
+    @JvmField
+    val HEALING_MACHINE = blockItem("healing_machine", CobblemonBlocks.HEALING_MACHINE)
+    @JvmField
+    val PC = blockItem("pc", CobblemonBlocks.PC)
+    @JvmField
+    val PASTURE = blockItem("pasture", CobblemonBlocks.PASTURE)
+
+    // Evolution items
+    @JvmField val LINK_CABLE = create("link_cable", LinkCableItem())
+    @JvmField val DRAGON_SCALE = noSettingsItem("dragon_scale")
+    @JvmField val KINGS_ROCK = noSettingsItem("kings_rock")
+    @JvmField val METAL_COAT = noSettingsItem("metal_coat")
+    @JvmField val UPGRADE = noSettingsItem("upgrade")
+    @JvmField val DUBIOUS_DISC = noSettingsItem("dubious_disc")
+    @JvmField val DEEP_SEA_SCALE = noSettingsItem("deep_sea_scale")
+    @JvmField val DEEP_SEA_TOOTH = noSettingsItem("deep_sea_tooth")
+    @JvmField val ELECTIRIZER = noSettingsItem("electirizer")
+    @JvmField val MAGMARIZER = noSettingsItem("magmarizer")
+    @JvmField val OVAL_STONE = noSettingsItem("oval_stone")
+    @JvmField val PROTECTOR = noSettingsItem("protector")
+    @JvmField val REAPER_CLOTH = noSettingsItem("reaper_cloth")
+    @JvmField val PRISM_SCALE = noSettingsItem("prism_scale")
+    @JvmField val SACHET = noSettingsItem("sachet")
+    @JvmField val WHIPPED_DREAM = noSettingsItem("whipped_dream")
+    @JvmField val STRAWBERRY_SWEET = noSettingsItem("strawberry_sweet")
+    @JvmField val LOVE_SWEET = noSettingsItem("love_sweet")
+    @JvmField val BERRY_SWEET = noSettingsItem("berry_sweet")
+    @JvmField val CLOVER_SWEET = noSettingsItem("clover_sweet")
+    @JvmField val FLOWER_SWEET = noSettingsItem("flower_sweet")
+    @JvmField val STAR_SWEET = noSettingsItem("star_sweet")
+    @JvmField val RIBBON_SWEET = noSettingsItem("ribbon_sweet")
+    @JvmField val CHIPPED_POT = noSettingsItem("chipped_pot")
+    @JvmField val CRACKED_POT = noSettingsItem("cracked_pot")
+    @JvmField val SWEET_APPLE = noSettingsItem("sweet_apple")
+    @JvmField val TART_APPLE = noSettingsItem("tart_apple")
+    @JvmField val GALARICA_CUFF = noSettingsItem("galarica_cuff")
+    @JvmField val GALARICA_WREATH = noSettingsItem("galarica_wreath")
+    @JvmField val BLACK_AUGURITE = noSettingsItem("black_augurite")
+    @JvmField val PEAT_BLOCK = noSettingsItem("peat_block")
+    @JvmField val RAZOR_CLAW = noSettingsItem("razor_claw")
+    @JvmField val RAZOR_FANG = noSettingsItem("razor_fang")
+    @JvmField val AUSPICIOUS_ARMOR = heldItem("auspicious_armor")
+    @JvmField val MALICIOUS_ARMOR = heldItem("malicious_armor")
+
+    private val berries = mutableMapOf<Identifier, BerryItem>()
+    // Plants
+    @JvmField val ORAN_BERRY = berryItem("oran", HealingBerryItem(CobblemonBlocks.ORAN_BERRY) { CobblemonMechanics.berries.oranRestoreAmount })
+    @JvmField val CHERI_BERRY = berryItem("cheri", StatusCuringBerryItem(CobblemonBlocks.CHERI_BERRY, Statuses.PARALYSIS))
+    @JvmField val CHESTO_BERRY = berryItem("chesto", StatusCuringBerryItem(CobblemonBlocks.CHESTO_BERRY, Statuses.SLEEP))
+    @JvmField val PECHA_BERRY = berryItem("pecha", StatusCuringBerryItem(CobblemonBlocks.PECHA_BERRY, Statuses.POISON, Statuses.POISON_BADLY))
+    @JvmField val RAWST_BERRY = berryItem("rawst", StatusCuringBerryItem(CobblemonBlocks.RAWST_BERRY, Statuses.BURN))
+    @JvmField val ASPEAR_BERRY = berryItem("aspear", StatusCuringBerryItem(CobblemonBlocks.ASPEAR_BERRY, Statuses.FROZEN))
+    @JvmField val PERSIM_BERRY = berryItem("persim", VolatileCuringBerryItem(CobblemonBlocks.PERSIM_BERRY, "confusion"))
+    @JvmField val RAZZ_BERRY = berryItem("razz", CobblemonBlocks.RAZZ_BERRY)
+    @JvmField val BLUK_BERRY = berryItem("bluk", CobblemonBlocks.BLUK_BERRY)
+    @JvmField val NANAB_BERRY = berryItem("nanab", CobblemonBlocks.NANAB_BERRY)
+    @JvmField val WEPEAR_BERRY = berryItem("wepear", CobblemonBlocks.WEPEAR_BERRY)
+    @JvmField val PINAP_BERRY = berryItem("pinap", CobblemonBlocks.PINAP_BERRY)
+    @JvmField val OCCA_BERRY = berryItem("occa", CobblemonBlocks.OCCA_BERRY)
+    @JvmField val PASSHO_BERRY = berryItem("passho", CobblemonBlocks.PASSHO_BERRY)
+    @JvmField val WACAN_BERRY = berryItem("wacan", CobblemonBlocks.WACAN_BERRY)
+    @JvmField val RINDO_BERRY = berryItem("rindo", CobblemonBlocks.RINDO_BERRY)
+    @JvmField val YACHE_BERRY = berryItem("yache", CobblemonBlocks.YACHE_BERRY)
+    @JvmField val CHOPLE_BERRY = berryItem("chople", CobblemonBlocks.CHOPLE_BERRY)
+    @JvmField val KEBIA_BERRY = berryItem("kebia", CobblemonBlocks.KEBIA_BERRY)
+    @JvmField val SHUCA_BERRY = berryItem("shuca", CobblemonBlocks.SHUCA_BERRY)
+    @JvmField val COBA_BERRY = berryItem("coba", CobblemonBlocks.COBA_BERRY)
+    @JvmField val PAYAPA_BERRY = berryItem("payapa", CobblemonBlocks.PAYAPA_BERRY)
+    @JvmField val TANGA_BERRY = berryItem("tanga", CobblemonBlocks.TANGA_BERRY)
+    @JvmField val CHARTI_BERRY = berryItem("charti", CobblemonBlocks.CHARTI_BERRY)
+    @JvmField val KASIB_BERRY = berryItem("kasib", CobblemonBlocks.KASIB_BERRY)
+    @JvmField val HABAN_BERRY = berryItem("haban", CobblemonBlocks.HABAN_BERRY)
+    @JvmField val COLBUR_BERRY = berryItem("colbur", CobblemonBlocks.COLBUR_BERRY)
+    @JvmField val BABIRI_BERRY = berryItem("babiri", CobblemonBlocks.BABIRI_BERRY)
+    @JvmField val CHILAN_BERRY = berryItem("chilan", CobblemonBlocks.CHILAN_BERRY)
+    @JvmField val ROSELI_BERRY = berryItem("roseli", CobblemonBlocks.ROSELI_BERRY)
+    @JvmField val LEPPA_BERRY = berryItem("leppa", PPRestoringBerryItem(CobblemonBlocks.LEPPA_BERRY) { CobblemonMechanics.berries.ppRestoreAmount })
+    @JvmField val LUM_BERRY = berryItem("lum", StatusCuringBerryItem(CobblemonBlocks.LUM_BERRY))
+    @JvmField val FIGY_BERRY = berryItem("figy", PortionHealingBerryItem(CobblemonBlocks.FIGY_BERRY, true) { CobblemonMechanics.berries.portionHealRatio })
+    @JvmField val WIKI_BERRY = berryItem("wiki", PortionHealingBerryItem(CobblemonBlocks.WIKI_BERRY, true) { CobblemonMechanics.berries.portionHealRatio })
+    @JvmField val MAGO_BERRY = berryItem("mago", PortionHealingBerryItem(CobblemonBlocks.MAGO_BERRY, true) { CobblemonMechanics.berries.portionHealRatio })
+    @JvmField val AGUAV_BERRY = berryItem("aguav", PortionHealingBerryItem(CobblemonBlocks.AGUAV_BERRY, true) { CobblemonMechanics.berries.portionHealRatio })
+    @JvmField val IAPAPA_BERRY = berryItem("iapapa", PortionHealingBerryItem(CobblemonBlocks.IAPAPA_BERRY, true) { CobblemonMechanics.berries.portionHealRatio })
+    @JvmField val SITRUS_BERRY = berryItem("sitrus", HealingBerryItem(CobblemonBlocks.SITRUS_BERRY) { CobblemonMechanics.berries.sitrusHealAmount })
+    @JvmField val TOUGA_BERRY = berryItem("touga", CobblemonBlocks.TOUGA_BERRY)
+    @JvmField val CORNN_BERRY = berryItem("cornn", CobblemonBlocks.CORNN_BERRY)
+    @JvmField val MAGOST_BERRY = berryItem("magost", CobblemonBlocks.MAGOST_BERRY)
+    @JvmField val RABUTA_BERRY = berryItem("rabuta", CobblemonBlocks.RABUTA_BERRY)
+    @JvmField val NOMEL_BERRY = berryItem("nomel", CobblemonBlocks.NOMEL_BERRY)
+    @JvmField val ENIGMA_BERRY = berryItem("enigma", CobblemonBlocks.ENIGMA_BERRY)
+    @JvmField val POMEG_BERRY = berryItem("pomeg", FriendshipRaisingBerryItem(CobblemonBlocks.POMEG_BERRY, Stats.HP))
+    @JvmField val KELPSY_BERRY = berryItem("kelpsy", FriendshipRaisingBerryItem(CobblemonBlocks.KELPSY_BERRY, Stats.ATTACK))
+    @JvmField val QUALOT_BERRY = berryItem("qualot", FriendshipRaisingBerryItem(CobblemonBlocks.QUALOT_BERRY, Stats.DEFENCE))
+    @JvmField val HONDEW_BERRY = berryItem("hondew", FriendshipRaisingBerryItem(CobblemonBlocks.HONDEW_BERRY, Stats.SPECIAL_ATTACK))
+    @JvmField val GREPA_BERRY = berryItem("grepa", FriendshipRaisingBerryItem(CobblemonBlocks.GREPA_BERRY, Stats.SPECIAL_DEFENCE))
+    @JvmField val TAMATO_BERRY = berryItem("tamato", FriendshipRaisingBerryItem(CobblemonBlocks.TAMATO_BERRY, Stats.SPEED))
+    @JvmField val SPELON_BERRY = berryItem("spelon", CobblemonBlocks.SPELON_BERRY)
+    @JvmField val PAMTRE_BERRY = berryItem("pamtre", CobblemonBlocks.PAMTRE_BERRY)
+    @JvmField val WATMEL_BERRY = berryItem("watmel", CobblemonBlocks.WATMEL_BERRY)
+    @JvmField val DURIN_BERRY = berryItem("durin", CobblemonBlocks.DURIN_BERRY)
+    @JvmField val BELUE_BERRY = berryItem("belue", CobblemonBlocks.BELUE_BERRY)
+    @JvmField val KEE_BERRY = berryItem("kee", CobblemonBlocks.KEE_BERRY)
+    @JvmField val MARANGA_BERRY = berryItem("maranga", CobblemonBlocks.MARANGA_BERRY)
+    @JvmField val HOPO_BERRY = berryItem("hopo", PPRestoringBerryItem(CobblemonBlocks.HOPO_BERRY) { CobblemonMechanics.berries.ppRestoreAmount })
+    @JvmField val LIECHI_BERRY = berryItem("liechi", CobblemonBlocks.LIECHI_BERRY)
+    @JvmField val GANLON_BERRY = berryItem("ganlon", CobblemonBlocks.GANLON_BERRY)
+    @JvmField val SALAC_BERRY = berryItem("salac", CobblemonBlocks.SALAC_BERRY)
+    @JvmField val PETAYA_BERRY = berryItem("petaya", CobblemonBlocks.PETAYA_BERRY)
+    @JvmField val APICOT_BERRY = berryItem("apicot", CobblemonBlocks.APICOT_BERRY)
+    @JvmField val LANSAT_BERRY = berryItem("lansat", CobblemonBlocks.LANSAT_BERRY)
+    @JvmField val STARF_BERRY = berryItem("starf", CobblemonBlocks.STARF_BERRY)
+    @JvmField val MICLE_BERRY = berryItem("micle", CobblemonBlocks.MICLE_BERRY)
+    @JvmField val CUSTAP_BERRY = berryItem("custap", CobblemonBlocks.CUSTAP_BERRY)
+    @JvmField val JABOCA_BERRY = berryItem("jaboca", CobblemonBlocks.JABOCA_BERRY)
+    @JvmField val ROWAP_BERRY = berryItem("rowap", CobblemonBlocks.ROWAP_BERRY)
+
+    @JvmField val BERRY_JUICE = this.create("berry_juice", BerryJuiceItem())
+
+    // Medicine
+    @JvmField
+    val RARE_CANDY = candyItem("rare_candy") { _, pokemon -> pokemon.getExperienceToNextLevel() }
+    @JvmField
+    val EXPERIENCE_CANDY_XS = candyItem("exp_candy_xs") { _, _ -> CandyItem.DEFAULT_XS_CANDY_YIELD }
+    @JvmField
+    val EXPERIENCE_CANDY_S = candyItem("exp_candy_s") { _, _ -> CandyItem.DEFAULT_S_CANDY_YIELD }
+    @JvmField
+    val EXPERIENCE_CANDY_M = candyItem("exp_candy_m") { _, _ -> CandyItem.DEFAULT_M_CANDY_YIELD }
+    @JvmField
+    val EXPERIENCE_CANDY_L = candyItem("exp_candy_l") { _, _ -> CandyItem.DEFAULT_L_CANDY_YIELD }
+    @JvmField
+    val EXPERIENCE_CANDY_XL = candyItem("exp_candy_xl") { _, _ -> CandyItem.DEFAULT_XL_CANDY_YIELD }
+    @JvmField
+    val CALCIUM = create("calcium", VitaminItem(Stats.SPECIAL_ATTACK))
+    @JvmField
+    val CARBOS = create("carbos", VitaminItem(Stats.SPEED))
+    @JvmField
+    val HP_UP = create("hp_up", VitaminItem(Stats.HP))
+    @JvmField
+    val IRON = create("iron", VitaminItem(Stats.DEFENCE))
+    @JvmField
+    val PROTEIN = create("protein", VitaminItem(Stats.ATTACK))
+    @JvmField
+    val ZINC = create("zinc", VitaminItem(Stats.SPECIAL_DEFENCE))
+    @JvmField
+    val MEDICINAL_LEEK = create("medicinal_leek", MedicinalLeekItem(CobblemonBlocks.MEDICINAL_LEEK, Item.Settings().food(FoodComponent.Builder().snack().hunger(1).saturationModifier(0.2f).build())))
+    @JvmField
+    val ROASTED_LEEK = create("roasted_leek", Item(Item.Settings().food(FoodComponent.Builder().snack().hunger(3).saturationModifier(0.3f).build())))
+    @JvmField
+    val BRAISED_VIVICHOKE = create("braised_vivichoke", Item(Item.Settings().food(FoodComponent.Builder().hunger(6).saturationModifier(0.6f).build())))
+    @JvmField
+    val VIVICHOKE_DIP = create("vivichoke_dip", object : StewItem(Settings().maxCount(1)
+        .food(FoodComponent.Builder()
+            .hunger(10)
+            .saturationModifier(1.2F)
+            .statusEffect(StatusEffectInstance(StatusEffects.ABSORPTION, 900, 0), 1F)
+            .alwaysEdible()
+            .build())) {
+        override fun finishUsing(stack: ItemStack?, world: World?, user: LivingEntity?): ItemStack {
+            user?.clearStatusEffects()
+            return super.finishUsing(stack, world, user)
+        }
+    })
+    @JvmField
+    val ENERGY_ROOT = compostableItem("energy_root", EnergyRootItem(CobblemonBlocks.ENERGY_ROOT, Item.Settings().food(FoodComponent.Builder().hunger(1).snack().saturationModifier(0.2f).build())))
+    @JvmField
+    val REVIVAL_HERB = compostableItem("revival_herb", RevivalHerbItem(CobblemonBlocks.REVIVAL_HERB))
+    @JvmField
+    val PEP_UP_FLOWER = compostableBlockItem("pep_up_flower", CobblemonBlocks.PEP_UP_FLOWER)
+    @JvmField
+    val MEDICINAL_BREW = create("medicinal_brew", Item(Item.Settings()))
+    @JvmField
+    val REMEDY = create("remedy", RemedyItem(RemedyItem.NORMAL))
+    @JvmField
+    val FINE_REMEDY = create("fine_remedy", RemedyItem(RemedyItem.FINE))
+    @JvmField
+    val SUPERB_REMEDY = create("superb_remedy", RemedyItem(RemedyItem.SUPERB))
+
+    @JvmField
+    val POTION = create("potion", PotionItem(PotionType.POTION))
+    @JvmField
+    val SUPER_POTION = create("super_potion", PotionItem(PotionType.SUPER_POTION))
+    @JvmField
+    val HYPER_POTION = create("hyper_potion", PotionItem(PotionType.HYPER_POTION))
+    @JvmField
+    val MAX_POTION = create("max_potion", PotionItem(PotionType.MAX_POTION))
+    @JvmField
+    val FULL_RESTORE = create("full_restore", PotionItem(PotionType.FULL_RESTORE))
+
+    @JvmField
+    val HEAL_POWDER = create("heal_powder", HealPowderItem())
+    @JvmField
+    val LEEK_AND_POTATO_STEW = create("leek_and_potato_stew", StewItem(Item.Settings().food(FoodComponent.Builder().hunger(8).saturationModifier(0.6f).build()).maxCount(1)))
+    @JvmField
+    val REVIVE = create("revive", ReviveItem(max = false))
+    @JvmField
+    val MAX_REVIVE = create("max_revive", ReviveItem(max = true))
+    @JvmField
+    val PP_UP = create("pp_up", PPUpItem(1))
+    @JvmField
+    val PP_MAX = create("pp_max", PPUpItem(3))
+
+    @JvmField
+    val RED_MINT_SEEDS = mintSeed("red", MintType.RED.getCropBlock())
+    @JvmField
+    val RED_MINT_LEAF = mintLeaf("red", MintLeafItem(MintType.RED))
+    @JvmField
+    val BLUE_MINT_SEEDS = mintSeed("blue", MintType.BLUE.getCropBlock())
+    @JvmField
+    val BLUE_MINT_LEAF = mintLeaf("blue", MintLeafItem(MintType.BLUE))
+    @JvmField
+    val CYAN_MINT_SEEDS = mintSeed("cyan", MintType.CYAN.getCropBlock())
+    @JvmField
+    val CYAN_MINT_LEAF = mintLeaf("cyan", MintLeafItem(MintType.CYAN))
+    @JvmField
+    val PINK_MINT_SEEDS = mintSeed("pink", MintType.PINK.getCropBlock())
+    @JvmField
+    val PINK_MINT_LEAF = mintLeaf("pink", MintLeafItem(MintType.PINK))
+    @JvmField
+    val GREEN_MINT_SEEDS = mintSeed("green", MintType.GREEN.getCropBlock())
+    @JvmField
+    val GREEN_MINT_LEAF = mintLeaf("green", MintLeafItem(MintType.GREEN))
+    @JvmField
+    val WHITE_MINT_SEEDS = mintSeed("white", MintType.WHITE.getCropBlock())
+    @JvmField
+    val WHITE_MINT_LEAF = mintLeaf("white", MintLeafItem(MintType.WHITE))
+
+    val mints = mutableMapOf<String, MintItem>()
+
+    @JvmField
+    val LONELY_MINT = mintItem("lonely_mint", MintItem(Natures.LONELY))
+    @JvmField
+    val ADAMANT_MINT = mintItem("adamant_mint", MintItem(Natures.ADAMANT))
+    @JvmField
+    val NAUGHTY_MINT = mintItem("naughty_mint", MintItem(Natures.NAUGHTY))
+    @JvmField
+    val BRAVE_MINT = mintItem("brave_mint", MintItem(Natures.BRAVE))
+    @JvmField
+    val BOLD_MINT = mintItem("bold_mint", MintItem(Natures.BOLD))
+    @JvmField
+    val IMPISH_MINT = mintItem("impish_mint", MintItem(Natures.IMPISH))
+    @JvmField
+    val LAX_MINT = mintItem("lax_mint", MintItem(Natures.LAX))
+    @JvmField
+    val RELAXED_MINT = mintItem("relaxed_mint", MintItem(Natures.RELAXED))
+    @JvmField
+    val MODEST_MINT = mintItem("modest_mint", MintItem(Natures.MODEST))
+    @JvmField
+    val MILD_MINT = mintItem("mild_mint", MintItem(Natures.MILD))
+    @JvmField
+    val RASH_MINT = mintItem("rash_mint", MintItem(Natures.RASH))
+    @JvmField
+    val QUIET_MINT = mintItem("quiet_mint", MintItem(Natures.QUIET))
+    @JvmField
+    val CALM_MINT = mintItem("calm_mint", MintItem(Natures.CALM))
+    @JvmField
+    val GENTLE_MINT = mintItem("gentle_mint", MintItem(Natures.GENTLE))
+    @JvmField
+    val CAREFUL_MINT = mintItem("careful_mint", MintItem(Natures.CAREFUL))
+    @JvmField
+    val SASSY_MINT = mintItem("sassy_mint", MintItem(Natures.SASSY))
+    @JvmField
+    val TIMID_MINT = mintItem("timid_mint", MintItem(Natures.TIMID))
+    @JvmField
+    val HASTY_MINT = mintItem("hasty_mint", MintItem(Natures.HASTY))
+    @JvmField
+    val JOLLY_MINT = mintItem("jolly_mint", MintItem(Natures.JOLLY))
+    @JvmField
+    val NAIVE_MINT = mintItem("naive_mint", MintItem(Natures.NAIVE))
+    @JvmField
+    val SERIOUS_MINT = mintItem("serious_mint", MintItem(Natures.SERIOUS))
+
+    @JvmField val X_ACCURACY = create("x_${Stats.ACCURACY.identifier.path}", XStatItem(Stats.ACCURACY))
+    @JvmField val X_ATTACK = create("x_${Stats.ATTACK.identifier.path}", XStatItem(Stats.ATTACK))
+    @JvmField val X_DEFENSE = create("x_${Stats.DEFENCE.identifier.path}", XStatItem(Stats.DEFENCE))
+    @JvmField val X_SP_ATK = create("x_${Stats.SPECIAL_ATTACK.identifier.path}", XStatItem(Stats.SPECIAL_ATTACK))
+    @JvmField val X_SP_DEF = create("x_${Stats.SPECIAL_DEFENCE.identifier.path}", XStatItem(Stats.SPECIAL_DEFENCE))
+    @JvmField val X_SPEED = create("x_${Stats.SPEED.identifier.path}", XStatItem(Stats.SPEED))
+
+    @JvmField val DIRE_HIT = create("dire_hit", DireHitItem())
+    @JvmField val GUARD_SPEC = create("guard_spec", GuardSpecItem())
+
+    @JvmField val BURN_HEAL = create("burn_heal", StatusCureItem("item.cobblemon.burn_heal", Statuses.BURN))
+    @JvmField val PARALYZE_HEAL = create("paralyze_heal", StatusCureItem("item.cobblemon.paralyze_heal", Statuses.PARALYSIS))
+    @JvmField val ICE_HEAL = create("ice_heal", StatusCureItem("item.cobblemon.ice_heal", Statuses.FROZEN))
+    @JvmField val ANTIDOTE = create("antidote", StatusCureItem("item.cobblemon.antidote", Statuses.POISON, Statuses.POISON_BADLY))
+    @JvmField val AWAKENING = create("awakening", StatusCureItem("item.cobblemon.awakening", Statuses.SLEEP))
+
+    @JvmField val FULL_HEAL = create("full_heal", StatusCureItem("item.cobblemon.full_heal"))
+
+    @JvmField val ETHER = create("ether", EtherItem(max = false))
+    @JvmField val MAX_ETHER = create("max_ether", EtherItem(max = true))
+    @JvmField val ELIXIR = create("elixir", ElixirItem(max = false))
+    @JvmField val MAX_ELIXIR = create("max_elixir", ElixirItem(max = true))
+
+    /**
+     * Evolution Ores and Stones
+     */
+    @JvmField
+    val DAWN_STONE_ORE = blockItem("dawn_stone_ore", CobblemonBlocks.DAWN_STONE_ORE)
+    @JvmField
+    val DUSK_STONE_ORE = blockItem("dusk_stone_ore", CobblemonBlocks.DUSK_STONE_ORE)
+    @JvmField
+    val FIRE_STONE_ORE = blockItem("fire_stone_ore", CobblemonBlocks.FIRE_STONE_ORE)
+    @JvmField
+    val ICE_STONE_ORE = blockItem("ice_stone_ore", CobblemonBlocks.ICE_STONE_ORE)
+    @JvmField
+    val LEAF_STONE_ORE = blockItem("leaf_stone_ore", CobblemonBlocks.LEAF_STONE_ORE)
+    @JvmField
+    val MOON_STONE_ORE = blockItem("moon_stone_ore", CobblemonBlocks.MOON_STONE_ORE)
+    @JvmField
+    val SHINY_STONE_ORE = blockItem("shiny_stone_ore", CobblemonBlocks.SHINY_STONE_ORE)
+    @JvmField
+    val SUN_STONE_ORE = blockItem("sun_stone_ore", CobblemonBlocks.SUN_STONE_ORE)
+    @JvmField
+    val THUNDER_STONE_ORE = blockItem("thunder_stone_ore", CobblemonBlocks.THUNDER_STONE_ORE)
+    @JvmField
+    val WATER_STONE_ORE = blockItem("water_stone_ore", CobblemonBlocks.WATER_STONE_ORE)
+    @JvmField
+    val DEEPSLATE_DAWN_STONE_ORE = blockItem("deepslate_dawn_stone_ore", CobblemonBlocks.DEEPSLATE_DAWN_STONE_ORE)
+    @JvmField
+    val DEEPSLATE_DUSK_STONE_ORE = blockItem("deepslate_dusk_stone_ore", CobblemonBlocks.DEEPSLATE_DUSK_STONE_ORE)
+    @JvmField
+    val DEEPSLATE_FIRE_STONE_ORE = blockItem("deepslate_fire_stone_ore", CobblemonBlocks.DEEPSLATE_FIRE_STONE_ORE)
+    @JvmField
+    val DEEPSLATE_ICE_STONE_ORE = blockItem("deepslate_ice_stone_ore", CobblemonBlocks.DEEPSLATE_ICE_STONE_ORE)
+    @JvmField
+    val DEEPSLATE_LEAF_STONE_ORE = blockItem("deepslate_leaf_stone_ore", CobblemonBlocks.DEEPSLATE_LEAF_STONE_ORE)
+    @JvmField
+    val DEEPSLATE_MOON_STONE_ORE = blockItem("deepslate_moon_stone_ore", CobblemonBlocks.DEEPSLATE_MOON_STONE_ORE)
+    @JvmField
+    val DEEPSLATE_SHINY_STONE_ORE = blockItem("deepslate_shiny_stone_ore", CobblemonBlocks.DEEPSLATE_SHINY_STONE_ORE)
+    @JvmField
+    val DEEPSLATE_SUN_STONE_ORE = blockItem("deepslate_sun_stone_ore", CobblemonBlocks.DEEPSLATE_SUN_STONE_ORE)
+    @JvmField
+    val DEEPSLATE_THUNDER_STONE_ORE = blockItem("deepslate_thunder_stone_ore", CobblemonBlocks.DEEPSLATE_THUNDER_STONE_ORE)
+    @JvmField
+    val DEEPSLATE_WATER_STONE_ORE = blockItem("deepslate_water_stone_ore", CobblemonBlocks.DEEPSLATE_WATER_STONE_ORE)
+    @JvmField
+    val DRIPSTONE_MOON_STONE_ORE = blockItem("dripstone_moon_stone_ore", CobblemonBlocks.DRIPSTONE_MOON_STONE_ORE)
+    @JvmField
+    val NETHER_FIRE_STONE_ORE = blockItem("nether_fire_stone_ore", CobblemonBlocks.NETHER_FIRE_STONE_ORE)
+
+    @JvmField
+    val DYNITE_ORE = blockItem("dynite_ore", CobblemonBlocks.DYNITE_ORE)
+
+    @JvmField
+    val DAWN_STONE = noSettingsItem("dawn_stone")
+    @JvmField
+    val DUSK_STONE = noSettingsItem("dusk_stone")
+    @JvmField
+    val FIRE_STONE = noSettingsItem("fire_stone")
+    @JvmField
+    val ICE_STONE = noSettingsItem("ice_stone")
+    @JvmField
+    val LEAF_STONE = noSettingsItem("leaf_stone")
+    @JvmField
+    val MOON_STONE = noSettingsItem("moon_stone")
+    @JvmField
+    val SHINY_STONE = noSettingsItem("shiny_stone")
+    @JvmField
+    val SUN_STONE = noSettingsItem("sun_stone")
+    @JvmField
+    val THUNDER_STONE = noSettingsItem("thunder_stone")
+    @JvmField
+    val WATER_STONE = noSettingsItem("water_stone")
+
+    // Held Items
+    @JvmField
+    val ASSAULT_VEST = heldItem("assault_vest")
+    @JvmField
+    val BIG_ROOT = blockItem("big_root", CobblemonBlocks.BIG_ROOT)
+    @JvmField
+    val BLACK_BELT = heldItem("black_belt")
+    @JvmField
+    val BLACK_GLASSES = heldItem("black_glasses")
+    @JvmField
+    val BLACK_SLUDGE = heldItem("black_sludge")
+    @JvmField
+    val CHARCOAL = heldItem("charcoal_stick", remappedName = "charcoal")
+    @JvmField
+    val CHOICE_BAND = heldItem("choice_band")
+    @JvmField
+    val CHOICE_SCARF = heldItem("choice_scarf")
+    @JvmField
+    val CHOICE_SPECS = heldItem("choice_specs")
+    @JvmField
+    val CLEANSE_TAG = heldItem("cleanse_tag")
+    @JvmField
+    val DRAGON_FANG = heldItem("dragon_fang")
+    @JvmField
+    val EXP_SHARE = heldItem("exp_share")
+    @JvmField
+    val FAIRY_FEATHER = heldItem("fairy_feather")
+    @JvmField
+    val FOCUS_BAND = heldItem("focus_band")
+    @JvmField
+    val HARD_STONE = heldItem("hard_stone")
+    @JvmField
+    val HEAVY_DUTY_BOOTS = heldItem("heavy_duty_boots")
+    @JvmField
+    val LEFTOVERS = heldItem("leftovers")
+    @JvmField
+    val LIGHT_CLAY = heldItem("light_clay")
+    @JvmField
+    val LUCKY_EGG = heldItem("lucky_egg")
+    @JvmField
+    val MAGNET = heldItem("magnet")
+    @JvmField
+    val MIRACLE_SEED = heldItem("miracle_seed")
+    @JvmField
+    val MUSCLE_BAND = heldItem("muscle_band")
+    @JvmField
+    val MYSTIC_WATER = heldItem("mystic_water")
+    @JvmField
+    val NEVER_MELT_ICE = heldItem("never_melt_ice")
+    @JvmField
+    val POISON_BARB = heldItem("poison_barb")
+    @JvmField
+    val QUICK_CLAW = heldItem("quick_claw")
+    @JvmField
+    val ROCKY_HELMET = heldItem("rocky_helmet")
+    @JvmField
+    val SAFETY_GOGGLES = heldItem("safety_goggles")
+    @JvmField
+    val SHARP_BEAK = heldItem("sharp_beak")
+    @JvmField
+    val SILK_SCARF = heldItem("silk_scarf")
+    @JvmField
+    val SILVER_POWDER = heldItem("silver_powder")
+    @JvmField
+    val SOFT_SAND = heldItem("soft_sand")
+    @JvmField
+    val SPELL_TAG = heldItem("spell_tag")
+    @JvmField
+    val TWISTED_SPOON = heldItem("twisted_spoon")
+    @JvmField
+    val WISE_GLASSES = heldItem("wise_glasses")
+    @JvmField
+    val MENTAL_HERB = compostableHeldItem("mental_herb", null, 1F)
+    @JvmField
+    val MIRROR_HERB = compostableHeldItem("mirror_herb", null, 1F)
+    @JvmField
+    val POWER_HERB = compostableHeldItem("power_herb", null, 1F)
+    @JvmField
+    val WHITE_HERB = compostableHeldItem("white_herb", null, 1F)
+    @JvmField
+    val BRIGHT_POWDER = heldItem("bright_powder")
+    @JvmField
+    val METAL_POWDER = heldItem("metal_powder")
+    @JvmField
+    val QUICK_POWDER = heldItem("quick_powder")
+    @JvmField
+    val DESTINY_KNOT = heldItem("destiny_knot")
+    @JvmField
+    val EVERSTONE = heldItem("everstone")
+    @JvmField
+    val POWER_ANKLET = heldItem("power_anklet")
+    @JvmField
+    val POWER_BAND = heldItem("power_band")
+    @JvmField
+    val POWER_BELT = heldItem("power_belt")
+    @JvmField
+    val POWER_BRACER = heldItem("power_bracer")
+    @JvmField
+    val POWER_LENS = heldItem("power_lens")
+    @JvmField
+    val POWER_WEIGHT = heldItem("power_weight")
+    @JvmField
+    val FLAME_ORB = heldItem("flame_orb")
+    @JvmField
+    val LIFE_ORB = heldItem("life_orb")
+    @JvmField
+    val TOXIC_ORB = heldItem("toxic_orb")
+    @JvmField
+    val SMOKE_BALL = heldItem("smoke_ball")
+
+    // Mulch
+    @JvmField
+    val MULCH_BASE = noSettingsItem("mulch_base")
+    @JvmField
+    val COARSE_MULCH = mulchItem("coarse_mulch", MulchVariant.COARSE)
+    @JvmField
+    val GROWTH_MULCH = mulchItem("growth_mulch", MulchVariant.GROWTH)
+    @JvmField
+    val HUMID_MULCH = mulchItem("humid_mulch", MulchVariant.HUMID)
+    @JvmField
+    val LOAMY_MULCH = mulchItem("loamy_mulch", MulchVariant.LOAMY)
+    @JvmField
+    val PEAT_MULCH = mulchItem("peat_mulch", MulchVariant.PEAT)
+    @JvmField
+    val RICH_MULCH = mulchItem("rich_mulch", MulchVariant.RICH)
+    @JvmField
+    val SANDY_MULCH = mulchItem("sandy_mulch", MulchVariant.SANDY)
+    @JvmField
+    val SURPRISE_MULCH = mulchItem("surprise_mulch", MulchVariant.SURPRISE)
+
+    // Archaeology
+    @JvmField
+    val ARMOR_FOSSIL = noSettingsItem("armor_fossil")
+    @JvmField
+    val BIRD_FOSSIL = noSettingsItem("bird_fossil")
+    @JvmField
+    val CLAW_FOSSIL = noSettingsItem("claw_fossil")
+    @JvmField
+    val COVER_FOSSIL = noSettingsItem("cover_fossil")
+    @JvmField
+    val DINO_FOSSIL = noSettingsItem("dino_fossil")
+    @JvmField
+    val DOME_FOSSIL = noSettingsItem("dome_fossil")
+    @JvmField
+    val DRAKE_FOSSIL = noSettingsItem("drake_fossil")
+    @JvmField
+    val FISH_FOSSIL = noSettingsItem("fish_fossil")
+    @JvmField
+    val HELIX_FOSSIL = noSettingsItem("helix_fossil")
+    @JvmField
+    val JAW_FOSSIL = noSettingsItem("jaw_fossil")
+    @JvmField
+    val OLD_AMBER_FOSSIL = noSettingsItem("old_amber_fossil")
+    @JvmField
+    val PLUME_FOSSIL = noSettingsItem("plume_fossil")
+    @JvmField
+    val ROOT_FOSSIL = noSettingsItem("root_fossil")
+    @JvmField
+    val SAIL_FOSSIL = noSettingsItem("sail_fossil")
+    @JvmField
+    val SKULL_FOSSIL = noSettingsItem("skull_fossil")
+
+    @JvmField
+    val BYGONE_SHERD = noSettingsItem("bygone_sherd")
+    @JvmField
+    val CAPTURE_SHERD = noSettingsItem("capture_sherd")
+    @JvmField
+    val DOME_SHERD = noSettingsItem("dome_sherd")
+    @JvmField
+    val HELIX_SHERD = noSettingsItem("helix_sherd")
+    @JvmField
+    val NOSTALGIC_SHERD = noSettingsItem("nostalgic_sherd")
+    @JvmField
+    val SUSPICIOUS_SHERD = noSettingsItem("suspicious_sherd")
+
+    @JvmField
+    val TUMBLESTONE = this.create("tumblestone", TumblestoneItem(Item.Settings(), CobblemonBlocks.SMALL_BUDDING_TUMBLESTONE))
+    @JvmField
+    val BLACK_TUMBLESTONE = this.create("black_tumblestone", TumblestoneItem(Item.Settings(), CobblemonBlocks.SMALL_BUDDING_BLACK_TUMBLESTONE))
+    @JvmField
+    val SKY_TUMBLESTONE = this.create("sky_tumblestone", TumblestoneItem(Item.Settings(), CobblemonBlocks.SMALL_BUDDING_SKY_TUMBLESTONE))
+
+    @JvmField
+    val SMALL_BUDDING_TUMBLESTONE = blockItem("small_budding_tumblestone", CobblemonBlocks.SMALL_BUDDING_TUMBLESTONE)
+    @JvmField
+    val MEDIUM_BUDDING_TUMBLESTONE = blockItem("medium_budding_tumblestone", CobblemonBlocks.MEDIUM_BUDDING_TUMBLESTONE)
+    @JvmField
+    val LARGE_BUDDING_TUMBLESTONE = blockItem("large_budding_tumblestone", CobblemonBlocks.LARGE_BUDDING_TUMBLESTONE)
+    @JvmField
+    val TUMBLESTONE_CLUSTER = blockItem("tumblestone_cluster", CobblemonBlocks.TUMBLESTONE_CLUSTER)
+
+    @JvmField
+    val SMALL_BUDDING_SKY_TUMBLESTONE = blockItem("small_budding_sky_tumblestone", CobblemonBlocks.SMALL_BUDDING_SKY_TUMBLESTONE)
+    @JvmField
+    val MEDIUM_BUDDING_SKY_TUMBLESTONE = blockItem("medium_budding_sky_tumblestone", CobblemonBlocks.MEDIUM_BUDDING_SKY_TUMBLESTONE)
+    @JvmField
+    val LARGE_BUDDING_SKY_TUMBLESTONE = blockItem("large_budding_sky_tumblestone", CobblemonBlocks.LARGE_BUDDING_SKY_TUMBLESTONE)
+    @JvmField
+    val SKY_TUMBLESTONE_CLUSTER = blockItem("sky_tumblestone_cluster", CobblemonBlocks.SKY_TUMBLESTONE_CLUSTER)
+
+    @JvmField
+    val SMALL_BUDDING_BLACK_TUMBLESTONE = blockItem("small_budding_black_tumblestone", CobblemonBlocks.SMALL_BUDDING_BLACK_TUMBLESTONE)
+    @JvmField
+    val MEDIUM_BUDDING_BLACK_TUMBLESTONE = blockItem("medium_budding_black_tumblestone", CobblemonBlocks.MEDIUM_BUDDING_BLACK_TUMBLESTONE)
+    @JvmField
+    val LARGE_BUDDING_BLACK_TUMBLESTONE = blockItem("large_budding_black_tumblestone", CobblemonBlocks.LARGE_BUDDING_BLACK_TUMBLESTONE)
+    @JvmField
+    val BLACK_TUMBLESTONE_CLUSTER = blockItem("black_tumblestone_cluster", CobblemonBlocks.BLACK_TUMBLESTONE_CLUSTER)
+
+    @JvmField
+    val TUMBLESTONE_BLOCK = blockItem("tumblestone_block", CobblemonBlocks.TUMBLESTONE_BLOCK)
+    @JvmField
+    val SKY_TUMBLESTONE_BLOCK = blockItem("sky_tumblestone_block", CobblemonBlocks.SKY_TUMBLESTONE_BLOCK)
+    @JvmField
+    val BLACK_TUMBLESTONE_BLOCK = blockItem("black_tumblestone_block", CobblemonBlocks.BLACK_TUMBLESTONE_BLOCK)
+
+    @JvmField
+    val AUTOMATON_ARMOR_TRIM_SMITHING_TEMPLATE: SmithingTemplateItem = this.create(
+        "automaton_armor_trim_smithing_template",
+        SmithingTemplateItem.of(CobblemonArmorTrims.AUTOMATON)
+    )
+
+    @JvmField
+    val POKEROD = pokerodItem("pokerod")
+
+    // Misc
+    @JvmField
+    val POKEMON_MODEL = this.create("pokemon_model", PokemonItem())
+
+    private fun blockItem(name: String, block: Block): BlockItem = this.create(name, BlockItem(block, Item.Settings()))
+
+    private fun noSettingsItem(name: String): CobblemonItem = this.create(name, CobblemonItem(Item.Settings()))
+
+    fun berries() = this.berries.toMap()
+
+    private fun mulchItem(name: String, mulchVariant: MulchVariant): MulchItem = this.create(name, MulchItem(mulchVariant))
+
+    private fun pokeBallItem(pokeBall: PokeBall): PokeBallItem {
+        val item = create(pokeBall.name.path, PokeBallItem(pokeBall))
+        pokeBall.item = item
+        pokeBalls.add(item)
+        return item
+    }
+
+    private fun candyItem(name: String, calculator: CandyItem.Calculator): CandyItem  = this.create(name, CandyItem(calculator))
+
+    private fun pokerodItem(name: String): PokerodItem {
+        var settings = Item.Settings()
+        val item = create(name, PokerodItem(settings))
+        return item
+    }
+
+    private fun heldItem(name: String, remappedName: String? = null): CobblemonItem = create(
+        name,
+        CobblemonItem(Item.Settings()).also {
+            if (remappedName != null) {
+                CobblemonHeldItemManager.registerRemap(it, remappedName)
+            }
+        }
+    )
+
+    private fun compostable(item: Item, increaseLevelChance: Float) = Cobblemon.implementation.registerCompostable(item, increaseLevelChance)
+
+    private fun berryItem(name: String, berryBlock: BerryBlock): BerryItem {
+        val finalName = "${name}_berry"
+        val item = this.create(finalName, BerryItem(berryBlock))
+        compostable(item, .65f)
+        this.berries[cobblemonResource(finalName)] = item
+        return item
+    }
+
+    private fun berryItem(name: String, berryItem: BerryItem): BerryItem {
+        val finalName = "${name}_berry"
+        val item = this.create(finalName, berryItem)
+        compostable(item, .65f)
+        this.berries[cobblemonResource(finalName)] = item
+        return item
+    }
+
+    private fun mintItem(name: String, mintItem: MintItem): MintItem {
+        val item = this.create(name, mintItem)
+        mints[item.nature.displayName] = item
+        compostable(item, .65f)
+        return item
+    }
+
+    private fun apricornItem(name: String, apricornItem: ApricornItem): ApricornItem {
+        val finalName = "${name}_apricorn"
+        val item = this.create(finalName, apricornItem)
+        compostable(item, .65f)
+        return item
+    }
+
+    private fun apricornSeedItem(name: String, apricornSeedItem: ApricornSeedItem): ApricornSeedItem {
+        val finalName = "${name}_apricorn_seed"
+        val item = this.create(finalName, apricornSeedItem)
+        compostable(item, .65f)
+        return item
+    }
+
+    private fun mintSeed(name: String, mintBlock: MintBlock): Item {
+        val finalName = "${name}_mint_seeds"
+        val item = this.blockItem(finalName, mintBlock)
+        compostable(item, .65f)
+        return item
+    }
+
+    private fun mintLeaf(name: String, mintLeafItem: MintLeafItem): MintLeafItem {
+        val finalName = "${name}_mint_leaf"
+        val item = this.create(finalName, mintLeafItem)
+        compostable(item, .65f)
+        return item
+    }
+
+    private fun compostableItem(name: String, item: Item? = null, increaseLevelChance: Float = .65f): Item {
+        val createdItem = this.create(name, item ?: Item(Item.Settings()))
+        compostable(createdItem, increaseLevelChance)
+        return createdItem
+    }
+
+    private fun compostableHeldItem(name: String, remappedName: String? = null, increaseLevelChance: Float = .65f): CobblemonItem {
+        val createdItem = heldItem(name, remappedName)
+        compostable(createdItem, increaseLevelChance)
+        return createdItem
+    }
+
+    private fun compostableBlockItem(name: String, block: Block, increaseLevelChance: Float = .65f): Item {
+        val createdItem = this.blockItem(name, block)
+        compostable(createdItem, increaseLevelChance)
+        return createdItem
+    }
+
+}

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

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.bedrockk.molang.Expression
+import com.cobblemon.mod.common.api.data.DataRegistry
+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.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)
+        .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/CobblemonNetwork.kt

@@ -0,0 +1,466 @@
+/*
+ * 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.BattleApplyPassResponseHandler
+import com.cobblemon.mod.common.client.net.battle.BattleCaptureEndHandler
+import com.cobblemon.mod.common.client.net.battle.BattleCaptureShakeHandler
+import com.cobblemon.mod.common.client.net.battle.BattleCaptureStartHandler
+import com.cobblemon.mod.common.client.net.battle.BattleChallengeExpiredHandler
+import com.cobblemon.mod.common.client.net.battle.BattleChallengeNotificationHandler
+import com.cobblemon.mod.common.client.net.battle.BattleEndHandler
+import com.cobblemon.mod.common.client.net.battle.BattleFaintHandler
+import com.cobblemon.mod.common.client.net.battle.BattleHealthChangeHandler
+import com.cobblemon.mod.common.client.net.battle.BattleInitializeHandler
+import com.cobblemon.mod.common.client.net.battle.BattleMadeInvalidChoiceHandler
+import com.cobblemon.mod.common.client.net.battle.BattleMakeChoiceHandler
+import com.cobblemon.mod.common.client.net.battle.BattleMessageHandler
+import com.cobblemon.mod.common.client.net.battle.BattleMusicHandler
+import com.cobblemon.mod.common.client.net.battle.BattlePersistentStatusHandler
+import com.cobblemon.mod.common.client.net.battle.BattleQueueRequestHandler
+import com.cobblemon.mod.common.client.net.battle.BattleSetTeamPokemonHandler
+import com.cobblemon.mod.common.client.net.battle.BattleSwitchPokemonHandler
+import com.cobblemon.mod.common.client.net.battle.BattleUpdateTeamPokemonHandler
+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.effect.RunPosableMoLangHandler
+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.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.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.MovesRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.PropertiesCompletionRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.SpeciesRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.UnlockReloadPacket
+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.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.*
+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.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.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 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
+import kotlin.reflect.KClass
+
+/**
+ * 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(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)
+
+
+
+        // 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(UnlockReloadPacket.ID, UnlockReloadPacket::decode, UnlockReloadPacketHandler)
+        this.createClientBound(BerryRegistrySyncPacket.ID, BerryRegistrySyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(NaturalMaterialRegistrySyncPacket.ID, NaturalMaterialRegistrySyncPacket::decode, DataRegistrySyncPacketHandler())
+        this.createClientBound(FossilRegistrySyncPacket.ID, FossilRegistrySyncPacket::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)
+    }
+
+    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)
+    }
+
+    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/CobblemonSounds.kt

@@ -0,0 +1,188 @@
+/*
+ * 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
+
+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 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("fossilmachine.activate")
+    @JvmField
+    val FOSSIL_MACHINE_ACTIVE_LOOP = this.create("fossilmachine.active_loop")
+    @JvmField
+    val FOSSIL_MACHINE_ASSEMBLE = this.create("fossilmachine.assemble")
+    @JvmField
+    val FOSSIL_MACHINE_DNA_FULL = this.create("fossilmachine.dna_full")
+    @JvmField
+    val FOSSIL_MACHINE_FINISHED = this.create("fossilmachine.finished")
+    @JvmField
+    val FOSSIL_MACHINE_INSERT_DNA = this.create("fossilmachine.insert_dna")
+    @JvmField
+    val FOSSIL_MACHINE_INSERT_DNA_SMALL = this.create("fossilmachine.insert_dna_small")
+    @JvmField
+    val FOSSIL_MACHINE_INSERT_FOSSIL = this.create("fossilmachine.insert_fossil")
+    @JvmField
+    val FOSSIL_MACHINE_RETRIEVE_FOSSIL = this.create("fossilmachine.retrieve_fossil")
+    @JvmField
+    val FOSSIL_MACHINE_RETRIEVE_POKEMON = this.create("fossilmachine.retrieve_pokemon")
+    @JvmField
+    val FOSSIL_MACHINE_UNPROTECTED = this.create("fossilmachine.unprotected")
+
+    @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 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
+    )
+
+    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,92 @@
+/*
+ * 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))))
+        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,118 @@
+/*
+ * 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
+        )
+    )
+
+    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/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/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,80 @@
+/*
+ * 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.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, var 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.
+     * If -1 the ability will attempt to find the correct index or reroll itself, this is done in order to be compatible with existing data
+     * The value can be mutated however this is not recommended by API users.
+     */
+    var index: Int = -1
+
+    /**
+     * The last known priority of this ability in the species data.
+     * The value can be mutated however this is not recommended by API users.
+     */
+    var priority = Priority.LOWEST
+
+    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 {
+        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 {
+        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)
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/abilities/PotentialAbility.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.api.abilities
+
+import com.cobblemon.mod.common.api.Priority
+import com.google.gson.JsonElement
+
+interface PotentialAbilityType<T : PotentialAbility> {
+    fun parseFromJSON(element: JsonElement): T?
+}
+
+/**
+ * An ability on a species that may or may not be available for a specific instance of the species.
+ *
+ * Controls whether a Pokémon can learn an ability.
+ *
+ * @author Hiroku
+ * @since July 27th, 2022
+ */
+interface PotentialAbility {
+    val template: AbilityTemplate
+    val priority: Priority
+    val type: PotentialAbilityType<*>
+    fun isSatisfiedBy(aspects: Set<String>): Boolean
+    companion object {
+        val types = mutableListOf<PotentialAbilityType<*>>()
+    }
+}
+
+object CommonAbilityType : PotentialAbilityType<CommonAbility> {
+    override fun parseFromJSON(element: JsonElement): CommonAbility? {
+        val str = if (element.isJsonPrimitive) element.asString else null
+        return str?.let {
+            val ability = Abilities.get(it)
+            if (ability != null) {
+                return@let CommonAbility(ability)
+            } else {
+                return@let null
+            }
+        }
+    }
+}
+
+open class CommonAbility(override val template: AbilityTemplate) : PotentialAbility {
+    override val priority = Priority.LOWEST
+    override val type = CommonAbilityType
+    override fun isSatisfiedBy(aspects: Set<String>) = true
+}
+

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/SleepDepth.kt

@@ -0,0 +1,51 @@
+/*
+ * 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.ai
+
+import com.cobblemon.mod.common.api.serialization.StringIdentifiedObjectAdapter
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import net.minecraft.entity.ai.TargetPredicate
+import net.minecraft.util.math.Box
+
+/**
+ * How deeply a Pokémon sleeps. This takes the current situation and decides if a Pokémon should fall asleep or wake.
+ *
+ * A depth should be registered by name in [SleepDepth.depths].
+ *
+ * @author Hiroku
+ * @since July 17th, 2022
+ */
+interface SleepDepth {
+    companion object {
+        val comatose = object : SleepDepth {
+            override fun canSleep(pokemonEntity: PokemonEntity) = true
+            override fun shouldWake(pokemonEntity: PokemonEntity) = true
+        }
+
+        val normal = object : SleepDepth {
+            override fun canSleep(pokemonEntity: PokemonEntity): Boolean {
+                return pokemonEntity.world.getPlayers(TargetPredicate.createNonAttackable(), pokemonEntity, Box.of(pokemonEntity.pos, 16.0, 16.0, 16.0)).isEmpty()
+            }
+
+            override fun shouldWake(pokemonEntity: PokemonEntity): Boolean {
+                val nearbyPlayers = pokemonEntity.world.getPlayers(TargetPredicate.createNonAttackable(), pokemonEntity, Box.of(pokemonEntity.pos, 16.0, 16.0, 16.0))
+                return nearbyPlayers.any { !it.isSneaking }
+            }
+        }
+
+        val depths = mutableMapOf(
+            "comatose" to comatose,
+            "normal" to normal
+        )
+        val adapter = StringIdentifiedObjectAdapter { depths[it] ?: throw IllegalArgumentException("Unknown sleep depth: $it") }
+    }
+
+    fun canSleep(pokemonEntity: PokemonEntity): Boolean
+    fun shouldWake(pokemonEntity: PokemonEntity): Boolean
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/apricorn/Apricorn.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.apricorn
+
+import com.cobblemon.mod.common.CobblemonBlocks
+import com.cobblemon.mod.common.CobblemonItems
+import com.cobblemon.mod.common.block.ApricornBlock
+import com.cobblemon.mod.common.block.ApricornSaplingBlock
+import com.cobblemon.mod.common.item.ApricornItem
+import net.minecraft.block.MapColor
+import net.minecraft.item.BlockItem
+
+/**
+ * Contains the different Apricorn variants and util methods to get their item, block, seedling and sapling form.
+ *
+ * @author Licious
+ * @since October 29th, 2022
+ */
+enum class Apricorn {
+
+    BLACK,
+    BLUE,
+    GREEN,
+    PINK,
+    RED,
+    WHITE,
+    YELLOW;
+
+    fun item(): ApricornItem = when(this) {
+        BLACK -> CobblemonItems.BLACK_APRICORN
+        BLUE -> CobblemonItems.BLUE_APRICORN
+        GREEN -> CobblemonItems.GREEN_APRICORN
+        PINK -> CobblemonItems.PINK_APRICORN
+        RED -> CobblemonItems.RED_APRICORN
+        WHITE -> CobblemonItems.WHITE_APRICORN
+        YELLOW -> CobblemonItems.YELLOW_APRICORN
+    }
+
+    fun seed(): BlockItem = when(this) {
+        BLACK -> CobblemonItems.BLACK_APRICORN_SEED
+        BLUE -> CobblemonItems.BLUE_APRICORN_SEED
+        GREEN -> CobblemonItems.GREEN_APRICORN_SEED
+        PINK -> CobblemonItems.PINK_APRICORN_SEED
+        RED -> CobblemonItems.RED_APRICORN_SEED
+        WHITE -> CobblemonItems.WHITE_APRICORN_SEED
+        YELLOW -> CobblemonItems.YELLOW_APRICORN_SEED
+    }
+
+    fun block(): ApricornBlock = when(this) {
+        BLACK -> CobblemonBlocks.BLACK_APRICORN
+        BLUE -> CobblemonBlocks.BLUE_APRICORN
+        GREEN -> CobblemonBlocks.GREEN_APRICORN
+        PINK -> CobblemonBlocks.PINK_APRICORN
+        RED -> CobblemonBlocks.RED_APRICORN
+        WHITE -> CobblemonBlocks.WHITE_APRICORN
+        YELLOW -> CobblemonBlocks.YELLOW_APRICORN
+    }
+
+    fun sapling(): ApricornSaplingBlock = when(this) {
+        BLACK -> CobblemonBlocks.BLACK_APRICORN_SAPLING
+        BLUE -> CobblemonBlocks.BLUE_APRICORN_SAPLING
+        GREEN -> CobblemonBlocks.GREEN_APRICORN_SAPLING
+        PINK -> CobblemonBlocks.PINK_APRICORN_SAPLING
+        RED -> CobblemonBlocks.RED_APRICORN_SAPLING
+        WHITE -> CobblemonBlocks.WHITE_APRICORN_SAPLING
+        YELLOW -> CobblemonBlocks.YELLOW_APRICORN_SAPLING
+    }
+
+    fun mapColor(): MapColor = when(this) {
+        BLACK -> MapColor.BLACK
+        BLUE ->  MapColor.BLUE
+        GREEN ->  MapColor.GREEN
+        PINK ->  MapColor.PINK
+        RED ->  MapColor.RED
+        WHITE ->  MapColor.WHITE
+        YELLOW ->  MapColor.YELLOW
+    }
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/asset/JsonManifestWalker.kt

@@ -0,0 +1,82 @@
+/*
+ * 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.asset
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.Cobblemon.LOGGER
+import com.cobblemon.mod.common.util.fromJson
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.JsonArray
+import java.io.File
+import java.io.InputStreamReader
+import java.io.PrintWriter
+
+/**
+ * A utility object for managing the "manifest" based assets. A JSON in a directory named _MANIFEST.json
+ * is a list of all of the files in the folder that should be loaded.
+ *
+ * Rationale: On Forge this is completely unneeded, but the Fabric class loader is either bugged or
+ * designed in such a way that targeting a folder for an asset load returns a URI that cannot be converted
+ * into a path (which would then be used for file walking). As a result, arbitrarily loading all files in
+ * a folder is either not possible in Fabric or I don't know what trickery is required. A manifest means there
+ * will not be a blind searching for JSONs and in future enables us to make the manifest potentially compress
+ * all the JSONs into itself to speed up load times internally.
+ *
+ * @author Hiroku
+ * @since April 1st, 2022.
+ */
+object JsonManifestWalker {
+    /**
+     * Builds a manifest at [manifestPath] using the files inside the same folder.
+     *
+     * This is for internal use though we could make this more normalized later.
+     */
+    internal fun build(manifestPath: String) {
+        val file = File(manifestPath)
+        file.createNewFile()
+        val folder = file.parentFile
+        folder.mkdir()
+        val members = folder.listFiles { f: File -> f.extension == "json" && f.nameWithoutExtension != "_MANIFEST" }
+        val jsonArray = JsonArray()
+        members.forEach {
+            jsonArray.add(it.relativeTo(folder).toString())
+        }
+        val pw = PrintWriter(file)
+        GsonBuilder().setPrettyPrinting().create().toJson(jsonArray, pw)
+        pw.flush()
+        pw.close()
+    }
+
+    /**
+     * Loads the given manifest and all the files it references.
+     */
+    fun <T> load(clazz: Class<T>, folder: String, gson: Gson): List<T> {
+        val manifestPath = "/assets/${Cobblemon.MODID}/$folder/_MANIFEST.json"
+        val manifest = Cobblemon::class.java.getResourceAsStream(manifestPath)!!
+        val folderPath = manifestPath.substringBeforeLast("/")
+        val list = mutableListOf<T>()
+        val array = gson.fromJson<JsonArray>(InputStreamReader(manifest))
+        array.forEach {
+            val path = it.asString
+            val stream = Cobblemon.javaClass.getResourceAsStream("$folderPath/$path") ?: run {
+                LOGGER.error("manifest contains element $path which was not found.")
+                return@forEach
+            }
+            try {
+                list.add(gson.fromJson(InputStreamReader(stream), clazz))
+            } catch (exception: Exception) {
+                LOGGER.error("Issue loading manifest component: $path")
+                exception.printStackTrace()
+            }
+        }
+
+        return list
+    }
+}